From 1413e6d72c49d6f481ef836e1e59f29e3618c0dc Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Fri, 15 Feb 2013 15:30:47 -0600
Subject: [PATCH 01/10] Add initial translation

---
 Antlr4.Runtime/ANTLRErrorListener.cs          |   78 +
 Antlr4.Runtime/ANTLRErrorStrategy.cs          |  157 ++
 Antlr4.Runtime/ANTLRFileStream.cs             |   97 +
 Antlr4.Runtime/ANTLRInputStream.cs            |  308 +++
 Antlr4.Runtime/Antlr4.Runtime.csproj          |  126 +
 Antlr4.Runtime/Atn/ATN.cs                     |  223 ++
 Antlr4.Runtime/Atn/ATNConfig.cs               |  551 +++++
 Antlr4.Runtime/Atn/ATNConfigSet.cs            |  692 ++++++
 Antlr4.Runtime/Atn/ATNSimulator.cs            |  995 ++++++++
 Antlr4.Runtime/Atn/ATNState.cs                |  304 +++
 .../Atn/AbstractPredicateTransition.cs        |   42 +
 Antlr4.Runtime/Atn/ActionTransition.cs        |   78 +
 Antlr4.Runtime/Atn/ArrayPredictionContext.cs  |  274 +++
 Antlr4.Runtime/Atn/AtomTransition.cs          |   70 +
 Antlr4.Runtime/Atn/BasicBlockStartState.cs    |   43 +
 Antlr4.Runtime/Atn/BasicState.cs              |   43 +
 Antlr4.Runtime/Atn/BlockEndState.cs           |   49 +
 Antlr4.Runtime/Atn/BlockStartState.cs         |   44 +
 Antlr4.Runtime/Atn/DecisionState.cs           |   43 +
 Antlr4.Runtime/Atn/EmptyPredictionContext.cs  |  127 +
 Antlr4.Runtime/Atn/EpsilonTransition.cs       |   63 +
 Antlr4.Runtime/Atn/LL1Analyzer.cs             |  232 ++
 Antlr4.Runtime/Atn/LexerATNSimulator.cs       |  742 ++++++
 Antlr4.Runtime/Atn/LoopEndState.cs            |   46 +
 Antlr4.Runtime/Atn/NotSetTransition.cs        |   58 +
 Antlr4.Runtime/Atn/OrderedATNConfigSet.cs     |   69 +
 Antlr4.Runtime/Atn/ParserATNPathFinder.cs     |  177 ++
 Antlr4.Runtime/Atn/ParserATNSimulator.cs      | 2182 +++++++++++++++++
 Antlr4.Runtime/Atn/PlusBlockStartState.cs     |   56 +
 Antlr4.Runtime/Atn/PlusLoopbackState.cs       |   50 +
 .../Atn/PrecedencePredicateTransition.cs      |   71 +
 Antlr4.Runtime/Atn/PredicateTransition.cs     |   90 +
 Antlr4.Runtime/Atn/PredictionContext.cs       |  542 ++++
 Antlr4.Runtime/Atn/PredictionContextCache.cs  |  212 ++
 Antlr4.Runtime/Atn/RangeTransition.cs         |   70 +
 Antlr4.Runtime/Atn/RuleStartState.cs          |   48 +
 Antlr4.Runtime/Atn/RuleStopState.cs           |   55 +
 Antlr4.Runtime/Atn/RuleTransition.cs          |   75 +
 Antlr4.Runtime/Atn/SemanticContext.cs         |  418 ++++
 Antlr4.Runtime/Atn/SetTransition.cs           |   76 +
 Antlr4.Runtime/Atn/SimulatorState.cs          |   57 +
 .../Atn/SingletonPredictionContext.cs         |  126 +
 Antlr4.Runtime/Atn/StarBlockStartState.cs     |   44 +
 Antlr4.Runtime/Atn/StarLoopEntryState.cs      |   44 +
 Antlr4.Runtime/Atn/StarLoopbackState.cs       |   47 +
 Antlr4.Runtime/Atn/TokensStartState.cs        |   43 +
 Antlr4.Runtime/Atn/Transition.cs              |  134 +
 Antlr4.Runtime/Atn/WildcardTransition.cs      |   58 +
 Antlr4.Runtime/BailErrorStrategy.cs           |   93 +
 Antlr4.Runtime/BaseErrorListener.cs           |   61 +
 Antlr4.Runtime/BufferedTokenStream.cs         |  661 +++++
 Antlr4.Runtime/CharStream.cs                  |  112 +
 Antlr4.Runtime/CommonToken.cs                 |  255 ++
 Antlr4.Runtime/CommonTokenFactory.cs          |   92 +
 Antlr4.Runtime/CommonTokenStream.cs           |  156 ++
 Antlr4.Runtime/ConsoleErrorListener.cs        |   47 +
 Antlr4.Runtime/DefaultErrorStrategy.cs        |  549 +++++
 Antlr4.Runtime/Dependents.cs                  |   49 +
 Antlr4.Runtime/Dfa/AbstractEdgeMap.cs         |  117 +
 Antlr4.Runtime/Dfa/ArrayEdgeMap.cs            |  272 ++
 Antlr4.Runtime/Dfa/DFA.cs                     |  144 ++
 Antlr4.Runtime/Dfa/DFASerializer.cs           |  222 ++
 Antlr4.Runtime/Dfa/DFAState.cs                |  349 +++
 Antlr4.Runtime/Dfa/EdgeMap.cs                 |   67 +
 Antlr4.Runtime/Dfa/LexerDFASerializer.cs      |   48 +
 Antlr4.Runtime/Dfa/SingletonEdgeMap.cs        |  238 ++
 Antlr4.Runtime/Dfa/SparseEdgeMap.cs           |  293 +++
 Antlr4.Runtime/DiagnosticErrorListener.cs     |   73 +
 Antlr4.Runtime/FailedPredicateException.cs    |  110 +
 Antlr4.Runtime/InputMismatchException.cs      |   54 +
 Antlr4.Runtime/IntStream.cs                   |  362 +++
 Antlr4.Runtime/Lexer.cs                       |  567 +++++
 Antlr4.Runtime/LexerNoViableAltException.cs   |   86 +
 .../Misc/AbstractEqualityComparator.cs        |   50 +
 Antlr4.Runtime/Misc/Args.cs                   |   57 +
 Antlr4.Runtime/Misc/Array2DHashSet.cs         |  692 ++++++
 Antlr4.Runtime/Misc/DoubleKeyMap.cs           |  108 +
 Antlr4.Runtime/Misc/EqualityComparator.cs     |   74 +
 Antlr4.Runtime/Misc/FlexibleHashMap.cs        |  397 +++
 Antlr4.Runtime/Misc/Func0.cs                  |   40 +
 Antlr4.Runtime/Misc/Func1.cs                  |   40 +
 Antlr4.Runtime/Misc/IntSet.cs                 |   92 +
 Antlr4.Runtime/Misc/IntegerList.cs            |  346 +++
 Antlr4.Runtime/Misc/IntegerStack.cs           |   65 +
 Antlr4.Runtime/Misc/Interval.cs               |  226 ++
 Antlr4.Runtime/Misc/IntervalSet.cs            |  821 +++++++
 Antlr4.Runtime/Misc/MultiMap.cs               |   66 +
 .../Misc/ObjectEqualityComparator.cs          |   97 +
 Antlr4.Runtime/Misc/OrderedHashSet.cs         |  164 ++
 Antlr4.Runtime/Misc/ParseCanceledException.cs |   71 +
 Antlr4.Runtime/Misc/Predicate.cs              |   40 +
 Antlr4.Runtime/Misc/RuleDependencyChecker.cs  |  327 +++
 .../Misc/RuleDependencyProcessor.cs           |  865 +++++++
 Antlr4.Runtime/Misc/TestRig.cs                |  337 +++
 Antlr4.Runtime/Misc/Tuple.cs                  |   93 +
 Antlr4.Runtime/Misc/Utils.cs                  |  258 ++
 Antlr4.Runtime/NoViableAltException.cs        |   97 +
 Antlr4.Runtime/Parser.cs                      |  922 +++++++
 Antlr4.Runtime/ParserErrorListener.cs         |   71 +
 Antlr4.Runtime/ParserRuleContext.cs           |  382 +++
 Antlr4.Runtime/ProxyErrorListener.cs          |   62 +
 Antlr4.Runtime/ProxyParserErrorListener.cs    |   91 +
 Antlr4.Runtime/RecognitionException.cs        |  155 ++
 Antlr4.Runtime/Recognizer.cs                  |  219 ++
 Antlr4.Runtime/RuleContext.cs                 |  324 +++
 Antlr4.Runtime/Token.cs                       |  151 ++
 Antlr4.Runtime/TokenFactory.cs                |   59 +
 Antlr4.Runtime/TokenSource.cs                 |   96 +
 Antlr4.Runtime/TokenStream.cs                 |  245 ++
 Antlr4.Runtime/TokenStreamRewriter.cs         |  745 ++++++
 .../Tree/AbstractParseTreeVisitor.cs          |  231 ++
 Antlr4.Runtime/Tree/ErrorNode.cs              |   38 +
 Antlr4.Runtime/Tree/ErrorNodeImpl.cs          |   58 +
 Antlr4.Runtime/Tree/ParseTree.cs              |   82 +
 Antlr4.Runtime/Tree/ParseTreeListener.cs      |   46 +
 Antlr4.Runtime/Tree/ParseTreeProperty.cs      |   71 +
 Antlr4.Runtime/Tree/ParseTreeVisitor.cs       |   97 +
 Antlr4.Runtime/Tree/ParseTreeWalker.cs        |   88 +
 Antlr4.Runtime/Tree/RuleNode.cs               |   42 +
 Antlr4.Runtime/Tree/SyntaxTree.cs             |   64 +
 Antlr4.Runtime/Tree/TerminalNode.cs           |   42 +
 Antlr4.Runtime/Tree/TerminalNodeImpl.cs       |  123 +
 Antlr4.Runtime/Tree/Tree.cs                   |   88 +
 Antlr4.Runtime/Tree/Trees.cs                  |  215 ++
 Antlr4.Runtime/UnbufferedCharStream.cs        |  438 ++++
 Antlr4.Runtime/UnbufferedTokenStream.cs       |  422 ++++
 Antlr4.Runtime/WritableToken.cs               |   49 +
 127 files changed, 26445 insertions(+)
 create mode 100644 Antlr4.Runtime/ANTLRErrorListener.cs
 create mode 100644 Antlr4.Runtime/ANTLRErrorStrategy.cs
 create mode 100644 Antlr4.Runtime/ANTLRFileStream.cs
 create mode 100644 Antlr4.Runtime/ANTLRInputStream.cs
 create mode 100644 Antlr4.Runtime/Atn/ATN.cs
 create mode 100644 Antlr4.Runtime/Atn/ATNConfig.cs
 create mode 100644 Antlr4.Runtime/Atn/ATNConfigSet.cs
 create mode 100644 Antlr4.Runtime/Atn/ATNSimulator.cs
 create mode 100644 Antlr4.Runtime/Atn/ATNState.cs
 create mode 100644 Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/ActionTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/ArrayPredictionContext.cs
 create mode 100644 Antlr4.Runtime/Atn/AtomTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/BasicBlockStartState.cs
 create mode 100644 Antlr4.Runtime/Atn/BasicState.cs
 create mode 100644 Antlr4.Runtime/Atn/BlockEndState.cs
 create mode 100644 Antlr4.Runtime/Atn/BlockStartState.cs
 create mode 100644 Antlr4.Runtime/Atn/DecisionState.cs
 create mode 100644 Antlr4.Runtime/Atn/EmptyPredictionContext.cs
 create mode 100644 Antlr4.Runtime/Atn/EpsilonTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/LL1Analyzer.cs
 create mode 100644 Antlr4.Runtime/Atn/LexerATNSimulator.cs
 create mode 100644 Antlr4.Runtime/Atn/LoopEndState.cs
 create mode 100644 Antlr4.Runtime/Atn/NotSetTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
 create mode 100644 Antlr4.Runtime/Atn/ParserATNPathFinder.cs
 create mode 100644 Antlr4.Runtime/Atn/ParserATNSimulator.cs
 create mode 100644 Antlr4.Runtime/Atn/PlusBlockStartState.cs
 create mode 100644 Antlr4.Runtime/Atn/PlusLoopbackState.cs
 create mode 100644 Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/PredicateTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/PredictionContext.cs
 create mode 100644 Antlr4.Runtime/Atn/PredictionContextCache.cs
 create mode 100644 Antlr4.Runtime/Atn/RangeTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/RuleStartState.cs
 create mode 100644 Antlr4.Runtime/Atn/RuleStopState.cs
 create mode 100644 Antlr4.Runtime/Atn/RuleTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/SemanticContext.cs
 create mode 100644 Antlr4.Runtime/Atn/SetTransition.cs
 create mode 100644 Antlr4.Runtime/Atn/SimulatorState.cs
 create mode 100644 Antlr4.Runtime/Atn/SingletonPredictionContext.cs
 create mode 100644 Antlr4.Runtime/Atn/StarBlockStartState.cs
 create mode 100644 Antlr4.Runtime/Atn/StarLoopEntryState.cs
 create mode 100644 Antlr4.Runtime/Atn/StarLoopbackState.cs
 create mode 100644 Antlr4.Runtime/Atn/TokensStartState.cs
 create mode 100644 Antlr4.Runtime/Atn/Transition.cs
 create mode 100644 Antlr4.Runtime/Atn/WildcardTransition.cs
 create mode 100644 Antlr4.Runtime/BailErrorStrategy.cs
 create mode 100644 Antlr4.Runtime/BaseErrorListener.cs
 create mode 100644 Antlr4.Runtime/BufferedTokenStream.cs
 create mode 100644 Antlr4.Runtime/CharStream.cs
 create mode 100644 Antlr4.Runtime/CommonToken.cs
 create mode 100644 Antlr4.Runtime/CommonTokenFactory.cs
 create mode 100644 Antlr4.Runtime/CommonTokenStream.cs
 create mode 100644 Antlr4.Runtime/ConsoleErrorListener.cs
 create mode 100644 Antlr4.Runtime/DefaultErrorStrategy.cs
 create mode 100644 Antlr4.Runtime/Dependents.cs
 create mode 100644 Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
 create mode 100644 Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
 create mode 100644 Antlr4.Runtime/Dfa/DFA.cs
 create mode 100644 Antlr4.Runtime/Dfa/DFASerializer.cs
 create mode 100644 Antlr4.Runtime/Dfa/DFAState.cs
 create mode 100644 Antlr4.Runtime/Dfa/EdgeMap.cs
 create mode 100644 Antlr4.Runtime/Dfa/LexerDFASerializer.cs
 create mode 100644 Antlr4.Runtime/Dfa/SingletonEdgeMap.cs
 create mode 100644 Antlr4.Runtime/Dfa/SparseEdgeMap.cs
 create mode 100644 Antlr4.Runtime/DiagnosticErrorListener.cs
 create mode 100644 Antlr4.Runtime/FailedPredicateException.cs
 create mode 100644 Antlr4.Runtime/InputMismatchException.cs
 create mode 100644 Antlr4.Runtime/IntStream.cs
 create mode 100644 Antlr4.Runtime/Lexer.cs
 create mode 100644 Antlr4.Runtime/LexerNoViableAltException.cs
 create mode 100644 Antlr4.Runtime/Misc/AbstractEqualityComparator.cs
 create mode 100644 Antlr4.Runtime/Misc/Args.cs
 create mode 100644 Antlr4.Runtime/Misc/Array2DHashSet.cs
 create mode 100644 Antlr4.Runtime/Misc/DoubleKeyMap.cs
 create mode 100644 Antlr4.Runtime/Misc/EqualityComparator.cs
 create mode 100644 Antlr4.Runtime/Misc/FlexibleHashMap.cs
 create mode 100644 Antlr4.Runtime/Misc/Func0.cs
 create mode 100644 Antlr4.Runtime/Misc/Func1.cs
 create mode 100644 Antlr4.Runtime/Misc/IntSet.cs
 create mode 100644 Antlr4.Runtime/Misc/IntegerList.cs
 create mode 100644 Antlr4.Runtime/Misc/IntegerStack.cs
 create mode 100644 Antlr4.Runtime/Misc/Interval.cs
 create mode 100644 Antlr4.Runtime/Misc/IntervalSet.cs
 create mode 100644 Antlr4.Runtime/Misc/MultiMap.cs
 create mode 100644 Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
 create mode 100644 Antlr4.Runtime/Misc/OrderedHashSet.cs
 create mode 100644 Antlr4.Runtime/Misc/ParseCanceledException.cs
 create mode 100644 Antlr4.Runtime/Misc/Predicate.cs
 create mode 100644 Antlr4.Runtime/Misc/RuleDependencyChecker.cs
 create mode 100644 Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
 create mode 100644 Antlr4.Runtime/Misc/TestRig.cs
 create mode 100644 Antlr4.Runtime/Misc/Tuple.cs
 create mode 100644 Antlr4.Runtime/Misc/Utils.cs
 create mode 100644 Antlr4.Runtime/NoViableAltException.cs
 create mode 100644 Antlr4.Runtime/Parser.cs
 create mode 100644 Antlr4.Runtime/ParserErrorListener.cs
 create mode 100644 Antlr4.Runtime/ParserRuleContext.cs
 create mode 100644 Antlr4.Runtime/ProxyErrorListener.cs
 create mode 100644 Antlr4.Runtime/ProxyParserErrorListener.cs
 create mode 100644 Antlr4.Runtime/RecognitionException.cs
 create mode 100644 Antlr4.Runtime/Recognizer.cs
 create mode 100644 Antlr4.Runtime/RuleContext.cs
 create mode 100644 Antlr4.Runtime/Token.cs
 create mode 100644 Antlr4.Runtime/TokenFactory.cs
 create mode 100644 Antlr4.Runtime/TokenSource.cs
 create mode 100644 Antlr4.Runtime/TokenStream.cs
 create mode 100644 Antlr4.Runtime/TokenStreamRewriter.cs
 create mode 100644 Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
 create mode 100644 Antlr4.Runtime/Tree/ErrorNode.cs
 create mode 100644 Antlr4.Runtime/Tree/ErrorNodeImpl.cs
 create mode 100644 Antlr4.Runtime/Tree/ParseTree.cs
 create mode 100644 Antlr4.Runtime/Tree/ParseTreeListener.cs
 create mode 100644 Antlr4.Runtime/Tree/ParseTreeProperty.cs
 create mode 100644 Antlr4.Runtime/Tree/ParseTreeVisitor.cs
 create mode 100644 Antlr4.Runtime/Tree/ParseTreeWalker.cs
 create mode 100644 Antlr4.Runtime/Tree/RuleNode.cs
 create mode 100644 Antlr4.Runtime/Tree/SyntaxTree.cs
 create mode 100644 Antlr4.Runtime/Tree/TerminalNode.cs
 create mode 100644 Antlr4.Runtime/Tree/TerminalNodeImpl.cs
 create mode 100644 Antlr4.Runtime/Tree/Tree.cs
 create mode 100644 Antlr4.Runtime/Tree/Trees.cs
 create mode 100644 Antlr4.Runtime/UnbufferedCharStream.cs
 create mode 100644 Antlr4.Runtime/UnbufferedTokenStream.cs
 create mode 100644 Antlr4.Runtime/WritableToken.cs

diff --git a/Antlr4.Runtime/ANTLRErrorListener.cs b/Antlr4.Runtime/ANTLRErrorListener.cs
new file mode 100644
index 000000000..c73bf3bbb
--- /dev/null
+++ b/Antlr4.Runtime/ANTLRErrorListener.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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>How to emit recognition errors</summary>
+	public interface ANTLRErrorListener<Symbol>
+	{
+		/// <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. The
+		/// parser ANTLRErrorStrategy 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.
+		/// The 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).
+		/// </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, e has token at which we
+		/// started production for the decision.
+		/// </param>
+		/// <param name="line">
+		/// At what line in input to the error occur? This always refers to
+		/// stopTokenIndex
+		/// </param>
+		/// <param name="charPositionInLine">At what character position within that line did the error occur.
+		/// 	</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<T>(Recognizer<T, object> recognizer, T offendingSymbol, int line
+			, int charPositionInLine, string msg, RecognitionException e) where T:Symbol;
+	}
+}
diff --git a/Antlr4.Runtime/ANTLRErrorStrategy.cs b/Antlr4.Runtime/ANTLRErrorStrategy.cs
new file mode 100644
index 000000000..669a0030d
--- /dev/null
+++ b/Antlr4.Runtime/ANTLRErrorStrategy.cs
@@ -0,0 +1,157 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// The interface for defining strategies to deal with syntax errors
+	/// encountered during a parse by ANTLR-generated parsers and tree parsers.
+	/// </summary>
+	/// <remarks>
+	/// The interface for defining strategies to deal with syntax errors
+	/// encountered during a parse by ANTLR-generated parsers and tree parsers.
+	/// We distinguish between three different kinds of errors:
+	/// o The parser could not figure out which path to take in the ATN
+	/// (none of the available alternatives could possibly match)
+	/// o The current input does not match what we were looking for.
+	/// o A predicate evaluated to false.
+	/// The default implementation of this interface reports errors to any
+	/// error listeners of the parser. It also handles single token insertion
+	/// and deletion for mismatched elements.
+	/// We pass in the parser to each function so that the same strategy
+	/// can be shared between multiple parsers running at the same time.
+	/// This is just for flexibility, not that we need it for the default system.
+	/// TODO: To bail out upon first error, simply rethrow e?
+	/// TODO: what to do about lexers
+	/// </remarks>
+	public interface ANTLRErrorStrategy
+	{
+		/// <summary>
+		/// When matching elements within alternative, use this method
+		/// to recover.
+		/// </summary>
+		/// <remarks>
+		/// When matching elements within alternative, use this method
+		/// to recover. The default implementation uses single token
+		/// insertion and deletion. If you want to change the way ANTLR
+		/// response to mismatched element errors within an alternative,
+		/// implement this method.
+		/// From the recognizer, we can get the input stream to get
+		/// the current input symbol and we can get the current context.
+		/// That context gives us the current state within the ATN.
+		/// From that state, we can look at its transition to figure out
+		/// what was expected.
+		/// Because we can recover from a single token deletions by
+		/// "inserting" tokens, we need to specify what that implicitly created
+		/// token is. We use object, because it could be a tree node.
+		/// </remarks>
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		Token RecoverInline(Parser recognizer);
+
+		/// <summary>
+		/// Resynchronize the parser by consuming tokens until we find one
+		/// in the resynchronization set--loosely the set of tokens that can follow
+		/// the current rule.
+		/// </summary>
+		/// <remarks>
+		/// Resynchronize the parser by consuming tokens until we find one
+		/// in the resynchronization set--loosely the set of tokens that can follow
+		/// the current rule. The exception contains info you might want to
+		/// use to recover better.
+		/// </remarks>
+		void Recover(Parser recognizer, RecognitionException e);
+
+		/// <summary>
+		/// Make sure that the current lookahead symbol is consistent with
+		/// what were expecting at this point in the ATN.
+		/// </summary>
+		/// <remarks>
+		/// Make 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.
+		/// Implements Jim Idle's magic sync mechanism in closures and optional
+		/// subrules. E.g.,
+		/// a : sync ( stuff sync )* ;
+		/// sync : {consume to what can follow sync} ;
+		/// 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
+		/// classDef : 'class' ID '{' member* '}'
+		/// 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.
+		/// 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 { }.
+		/// </remarks>
+		void Sync(Parser recognizer);
+
+		/// <summary>Notify handler that parser has entered an error state.</summary>
+		/// <remarks>
+		/// Notify handler that parser has entered an error state.  The
+		/// parser currently doesn't call this--the handler itself calls this
+		/// in report error methods.  But, for symmetry with endErrorCondition,
+		/// this method is in the interface.
+		/// </remarks>
+		void BeginErrorCondition(Parser recognizer);
+
+		/// <summary>
+		/// Is the parser in the process of recovering from an error? Upon
+		/// a syntax error, the parser enters recovery mode and stays there until
+		/// the next successful match of a token.
+		/// </summary>
+		/// <remarks>
+		/// Is the parser in the process of recovering from an error? Upon
+		/// a syntax error, the parser enters recovery mode and stays there until
+		/// the next successful match of a token. In this way, we can
+		/// avoid sending out spurious error messages. We only want one error
+		/// message per syntax error
+		/// </remarks>
+		bool InErrorRecoveryMode(Parser recognizer);
+
+		/// <summary>Reset the error handler.</summary>
+		/// <remarks>
+		/// Reset the error handler. Call this when the parser
+		/// matches a valid token (indicating no longer in recovery mode)
+		/// and from its own reset method.
+		/// </remarks>
+		void EndErrorCondition(Parser recognizer);
+
+		/// <summary>Report any kind of RecognitionException.</summary>
+		/// <remarks>Report any kind of RecognitionException.</remarks>
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		void ReportError(Parser recognizer, RecognitionException e);
+	}
+}
diff --git a/Antlr4.Runtime/ANTLRFileStream.cs b/Antlr4.Runtime/ANTLRFileStream.cs
new file mode 100644
index 000000000..1fab3edaa
--- /dev/null
+++ b/Antlr4.Runtime/ANTLRFileStream.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 System.IO;
+using Antlr4.Runtime;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// This is an ANTLRInputStream that is loaded from a file
+	/// all at once when you construct the object.
+	/// </summary>
+	/// <remarks>
+	/// This is an ANTLRInputStream that is loaded from a file
+	/// all at once when you construct the object.  This is a special case
+	/// since we know the exact size of the object to load.  We can avoid lots
+	/// of data copying.
+	/// </remarks>
+	public class ANTLRFileStream : ANTLRInputStream
+	{
+		protected internal string fileName;
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRFileStream(string fileName) : this(fileName, null)
+		{
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRFileStream(string fileName, string encoding)
+		{
+			this.fileName = fileName;
+			Load(fileName, encoding);
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public virtual void Load(string fileName, string encoding)
+		{
+			if (fileName == null)
+			{
+				return;
+			}
+			FilePath f = new FilePath(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];
+				base.n = isr.Read(data);
+			}
+			finally
+			{
+				isr.Close();
+			}
+		}
+
+		public override string GetSourceName()
+		{
+			return fileName;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/ANTLRInputStream.cs b/Antlr4.Runtime/ANTLRInputStream.cs
new file mode 100644
index 000000000..4f614b9af
--- /dev/null
+++ b/Antlr4.Runtime/ANTLRInputStream.cs
@@ -0,0 +1,308 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>Vacuum all input from a Reader/InputStream and then treat it like a char[] buffer.
+	/// 	</summary>
+	/// <remarks>
+	/// Vacuum all input from a Reader/InputStream and then treat it like a char[] buffer.
+	/// Can also pass in a string or char[] to use.
+	/// If you need encoding, pass in stream/reader with correct encoding.
+	/// </remarks>
+	public class ANTLRInputStream : CharStream
+	{
+		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"></exception>
+		public ANTLRInputStream(StreamReader r) : this(r, InitialBufferSize, ReadBufferSize
+			)
+		{
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRInputStream(StreamReader r, int initialSize) : this(r, initialSize, ReadBufferSize
+			)
+		{
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRInputStream(StreamReader r, int initialSize, int readChunkSize)
+		{
+			Load(r, initialSize, readChunkSize);
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRInputStream(InputStream input) : this(new InputStreamReader(input), InitialBufferSize
+			)
+		{
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRInputStream(InputStream input, int initialSize) : this(new InputStreamReader
+			(input), initialSize)
+		{
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public ANTLRInputStream(InputStream input, int initialSize, int readChunkSize) : 
+			this(new InputStreamReader(input), initialSize, readChunkSize)
+		{
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public virtual void Load(StreamReader r, int size, int readChunkSize)
+		{
+			if (r == null)
+			{
+				return;
+			}
+			if (size <= 0)
+			{
+				size = InitialBufferSize;
+			}
+			if (readChunkSize <= 0)
+			{
+				readChunkSize = ReadBufferSize;
+			}
+			// System.out.println("load "+size+" in chunks of "+readChunkSize);
+			try
+			{
+				// alloc initial buffer size.
+				data = new char[size];
+				// read all the data in chunks of readChunkSize
+				int numRead = 0;
+				int p = 0;
+				do
+				{
+					if (p + readChunkSize > data.Length)
+					{
+						// overflow?
+						// System.out.println("### overflow p="+p+", data.length="+data.length);
+						data = Arrays.CopyOf(data, data.Length * 2);
+					}
+					numRead = r.Read(data, p, readChunkSize);
+					// System.out.println("read "+numRead+" chars; p was "+p+" is now "+(p+numRead));
+					p += numRead;
+				}
+				while (numRead != -1);
+				// while not EOF
+				// set the actual size of the data available;
+				// EOF subtracted one above in p+=numRead; add one back
+				n = p + 1;
+			}
+			finally
+			{
+				//System.out.println("n="+n);
+				r.Close();
+			}
+		}
+
+		/// <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) == IntStream.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 IntStream.Eof;
+				}
+			}
+			// invalid; no char before first char
+			if ((p + i - 1) >= n)
+			{
+				//System.out.println("char LA("+i+")=EOF; p="+p);
+				return IntStream.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()
+		{
+			return p;
+		}
+
+		public virtual int Size()
+		{
+			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
+			while (p < index && index < n)
+			{
+				Consume();
+			}
+		}
+
+		public override 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 GetSourceName()
+		{
+			return name;
+		}
+
+		public override string ToString()
+		{
+			return new string(data);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Antlr4.Runtime.csproj b/Antlr4.Runtime/Antlr4.Runtime.csproj
index da813927f..b66dd38c9 100644
--- a/Antlr4.Runtime/Antlr4.Runtime.csproj
+++ b/Antlr4.Runtime/Antlr4.Runtime.csproj
@@ -39,7 +39,133 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ANTLRErrorListener.cs" />
+    <Compile Include="ANTLRErrorStrategy.cs" />
+    <Compile Include="ANTLRFileStream.cs" />
+    <Compile Include="ANTLRInputStream.cs" />
+    <Compile Include="Atn\AbstractPredicateTransition.cs" />
+    <Compile Include="Atn\ActionTransition.cs" />
+    <Compile Include="Atn\ArrayPredictionContext.cs" />
+    <Compile Include="Atn\ATN.cs" />
+    <Compile Include="Atn\ATNConfig.cs" />
+    <Compile Include="Atn\ATNConfigSet.cs" />
+    <Compile Include="Atn\ATNSimulator.cs" />
+    <Compile Include="Atn\ATNState.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\DecisionState.cs" />
+    <Compile Include="Atn\EmptyPredictionContext.cs" />
+    <Compile Include="Atn\EpsilonTransition.cs" />
+    <Compile Include="Atn\LexerATNSimulator.cs" />
+    <Compile Include="Atn\LL1Analyzer.cs" />
+    <Compile Include="Atn\LoopEndState.cs" />
+    <Compile Include="Atn\NotSetTransition.cs" />
+    <Compile Include="Atn\OrderedATNConfigSet.cs" />
+    <Compile Include="Atn\ParserATNPathFinder.cs" />
+    <Compile Include="Atn\ParserATNSimulator.cs" />
+    <Compile Include="Atn\PlusBlockStartState.cs" />
+    <Compile Include="Atn\PlusLoopbackState.cs" />
+    <Compile Include="Atn\PrecedencePredicateTransition.cs" />
+    <Compile Include="Atn\PredicateTransition.cs" />
+    <Compile Include="Atn\PredictionContext.cs" />
+    <Compile Include="Atn\PredictionContextCache.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\TokensStartState.cs" />
+    <Compile Include="Atn\Transition.cs" />
+    <Compile Include="Atn\WildcardTransition.cs" />
+    <Compile Include="BailErrorStrategy.cs" />
+    <Compile Include="BaseErrorListener.cs" />
+    <Compile Include="BufferedTokenStream.cs" />
+    <Compile Include="CharStream.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\AbstractEdgeMap.cs" />
+    <Compile Include="Dfa\ArrayEdgeMap.cs" />
+    <Compile Include="Dfa\DFA.cs" />
+    <Compile Include="Dfa\DFASerializer.cs" />
+    <Compile Include="Dfa\DFAState.cs" />
+    <Compile Include="Dfa\EdgeMap.cs" />
+    <Compile Include="Dfa\LexerDFASerializer.cs" />
+    <Compile Include="Dfa\SingletonEdgeMap.cs" />
+    <Compile Include="Dfa\SparseEdgeMap.cs" />
+    <Compile Include="DiagnosticErrorListener.cs" />
+    <Compile Include="FailedPredicateException.cs" />
+    <Compile Include="InputMismatchException.cs" />
+    <Compile Include="IntStream.cs" />
+    <Compile Include="Lexer.cs" />
+    <Compile Include="LexerNoViableAltException.cs" />
+    <Compile Include="Misc\AbstractEqualityComparator.cs" />
+    <Compile Include="Misc\Args.cs" />
+    <Compile Include="Misc\Array2DHashSet.cs" />
+    <Compile Include="Misc\DoubleKeyMap.cs" />
+    <Compile Include="Misc\EqualityComparator.cs" />
+    <Compile Include="Misc\FlexibleHashMap.cs" />
+    <Compile Include="Misc\Func0.cs" />
+    <Compile Include="Misc\Func1.cs" />
+    <Compile Include="Misc\IntegerList.cs" />
+    <Compile Include="Misc\IntegerStack.cs" />
+    <Compile Include="Misc\Interval.cs" />
+    <Compile Include="Misc\IntervalSet.cs" />
+    <Compile Include="Misc\IntSet.cs" />
+    <Compile Include="Misc\MultiMap.cs" />
+    <Compile Include="Misc\ObjectEqualityComparator.cs" />
+    <Compile Include="Misc\OrderedHashSet.cs" />
+    <Compile Include="Misc\ParseCanceledException.cs" />
+    <Compile Include="Misc\Predicate.cs" />
+    <Compile Include="Misc\RuleDependencyChecker.cs" />
+    <Compile Include="Misc\RuleDependencyProcessor.cs" />
+    <Compile Include="Misc\TestRig.cs" />
+    <Compile Include="Misc\Tuple.cs" />
+    <Compile Include="Misc\Utils.cs" />
+    <Compile Include="NoViableAltException.cs" />
+    <Compile Include="Parser.cs" />
+    <Compile Include="ParserErrorListener.cs" />
+    <Compile Include="ParserRuleContext.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ProxyErrorListener.cs" />
+    <Compile Include="ProxyParserErrorListener.cs" />
+    <Compile Include="RecognitionException.cs" />
+    <Compile Include="Recognizer.cs" />
+    <Compile Include="RuleContext.cs" />
+    <Compile Include="Token.cs" />
+    <Compile Include="TokenFactory.cs" />
+    <Compile Include="TokenSource.cs" />
+    <Compile Include="TokenStream.cs" />
+    <Compile Include="TokenStreamRewriter.cs" />
+    <Compile Include="Tree\AbstractParseTreeVisitor.cs" />
+    <Compile Include="Tree\ErrorNode.cs" />
+    <Compile Include="Tree\ErrorNodeImpl.cs" />
+    <Compile Include="Tree\ParseTree.cs" />
+    <Compile Include="Tree\ParseTreeListener.cs" />
+    <Compile Include="Tree\ParseTreeProperty.cs" />
+    <Compile Include="Tree\ParseTreeVisitor.cs" />
+    <Compile Include="Tree\ParseTreeWalker.cs" />
+    <Compile Include="Tree\RuleNode.cs" />
+    <Compile Include="Tree\SyntaxTree.cs" />
+    <Compile Include="Tree\TerminalNode.cs" />
+    <Compile Include="Tree\TerminalNodeImpl.cs" />
+    <Compile Include="Tree\Tree.cs" />
+    <Compile Include="Tree\Trees.cs" />
+    <Compile Include="UnbufferedCharStream.cs" />
+    <Compile Include="UnbufferedTokenStream.cs" />
+    <Compile Include="WritableToken.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Antlr4.Runtime/Atn/ATN.cs b/Antlr4.Runtime/Atn/ATN.cs
new file mode 100644
index 000000000..0923f0171
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ATN.cs
@@ -0,0 +1,223 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public class ATN
+	{
+		public const int InvalidAltNumber = 0;
+
+		public const int Parser = 1;
+
+		public const int Lexer = 2;
+
+		[NotNull]
+		public readonly IList<ATNState> states = new AList<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 AList<DecisionState>();
+
+		public RuleStartState[] ruleToStartState;
+
+		public RuleStopState[] ruleToStopState;
+
+		[NotNull]
+		public readonly IDictionary<string, TokensStartState> modeNameToStartState = new 
+			LinkedHashMap<string, TokensStartState>();
+
+		public int grammarType;
+
+		public int maxTokenType;
+
+		public int[] ruleToTokenType;
+
+		public int[] ruleToActionIndex;
+
+		[NotNull]
+		public readonly IList<TokensStartState> modeToStartState = new AList<TokensStartState
+			>();
+
+		/// <summary>used during construction from grammar AST</summary>
+		internal int stateNumber = 0;
+
+		private readonly ConcurrentMap<PredictionContext, PredictionContext> contextCache
+			 = new ConcurrentHashMap<PredictionContext, PredictionContext>();
+
+		[NotNull]
+		public DFA[] decisionToDFA = new DFA[0];
+
+		[NotNull]
+		public DFA[] modeToDFA = new DFA[0];
+
+		protected internal readonly ConcurrentMap<int, int> LL1Table = new ConcurrentHashMap
+			<int, int>();
+
+		/// <summary>Used for runtime deserialization of ATNs from strings</summary>
+		public ATN()
+		{
+		}
+
+		// runtime for parsers, lexers
+		// ATN.LEXER, ...
+		// runtime for lexer only
+		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 GetContextCacheSize()
+		{
+			return contextCache.Count;
+		}
+
+		public virtual PredictionContext GetCachedContext(PredictionContext context)
+		{
+			return PredictionContext.GetCachedContext(context, contextCache, new PredictionContext.IdentityHashMap
+				());
+		}
+
+		public DFA[] GetDecisionToDFA()
+		{
+			System.Diagnostics.Debug.Assert(decisionToDFA != null && decisionToDFA.Length == 
+				decisionToState.Count);
+			return decisionToDFA;
+		}
+
+		/// <summary>Compute the set of valid tokens that can occur starting in s.</summary>
+		/// <remarks>
+		/// Compute the set of valid tokens that can occur starting in s.
+		/// If ctx is
+		/// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+		/// , the set of tokens will not include what can follow
+		/// the rule surrounding s. In other words, the set will be
+		/// restricted to tokens reachable staying within s's rule.
+		/// </remarks>
+		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 s and staying in same rule.
+		/// 	</summary>
+		/// <remarks>
+		/// Compute the set of valid tokens that can occur starting in s and staying in same rule.
+		/// EPSILON is in set if we reach end of rule.
+		/// </remarks>
+		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)
+			{
+				states.AddItem(null);
+				stateNumber++;
+				return;
+			}
+			state.atn = this;
+			states.AddItem(state);
+			state.stateNumber = stateNumber++;
+		}
+
+		public virtual void RemoveState(ATNState state)
+		{
+			states.Set(state.stateNumber, null);
+		}
+
+		// just free mem, don't shift states in list
+		public virtual void DefineMode(string name, TokensStartState s)
+		{
+			modeNameToStartState.Put(name, s);
+			modeToStartState.AddItem(s);
+			modeToDFA = Arrays.CopyOf(modeToDFA, modeToStartState.Count);
+			modeToDFA[modeToDFA.Length - 1] = new DFA(s);
+			DefineDecisionState(s);
+		}
+
+		public virtual int DefineDecisionState(DecisionState s)
+		{
+			decisionToState.AddItem(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.IsEmpty())
+			{
+				return decisionToState[decision];
+			}
+			return null;
+		}
+
+		public virtual int GetNumberOfDecisions()
+		{
+			return decisionToState.Count;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/ATNConfig.cs b/Antlr4.Runtime/Atn/ATNConfig.cs
new file mode 100644
index 000000000..51c3ef05a
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ATNConfig.cs
@@ -0,0 +1,551 @@
+/*
+ * [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 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>The ATN state associated with this configuration</summary>
+		[NotNull]
+		private readonly ATNState state;
+
+		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 & unchecked((int)(0x7FFFFFFF));
+			this.context = context;
+		}
+
+		protected internal ATNConfig(Antlr4.Runtime.Atn.ATNConfig c, ATNState state, PredictionContext
+			 context)
+		{
+			this.state = state;
+			this.altAndOuterContextDepth = c.altAndOuterContextDepth & unchecked((int)(0x7FFFFFFF
+				));
+			this.context = context;
+		}
+
+		public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
+			 context)
+		{
+			return Create(state, alt, context, SemanticContext.None, -1);
+		}
+
+		public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
+			 context, SemanticContext semanticContext)
+		{
+			return Create(state, alt, context, semanticContext, -1);
+		}
+
+		public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
+			 context, SemanticContext semanticContext, int actionIndex)
+		{
+			if (semanticContext != SemanticContext.None)
+			{
+				if (actionIndex != -1)
+				{
+					return new ATNConfig.ActionSemanticContextATNConfig(actionIndex, semanticContext, 
+						state, alt, context);
+				}
+				else
+				{
+					return new ATNConfig.SemanticContextATNConfig(semanticContext, state, alt, context
+						);
+				}
+			}
+			else
+			{
+				if (actionIndex != -1)
+				{
+					return new ATNConfig.ActionATNConfig(actionIndex, state, alt, context);
+				}
+				else
+				{
+					return new Antlr4.Runtime.Atn.ATNConfig(state, alt, context);
+				}
+			}
+		}
+
+		/// <summary>Gets the ATN state associated with this configuration</summary>
+		[NotNull]
+		public ATNState GetState()
+		{
+			return state;
+		}
+
+		/// <summary>What alt (or lexer rule) is predicted by this configuration</summary>
+		public int GetAlt()
+		{
+			return altAndOuterContextDepth & unchecked((int)(0x00FFFFFF));
+		}
+
+		public bool IsHidden()
+		{
+			return altAndOuterContextDepth < 0;
+		}
+
+		public virtual void SetHidden(bool value)
+		{
+			if (value)
+			{
+				altAndOuterContextDepth |= unchecked((int)(0x80000000));
+			}
+			else
+			{
+				altAndOuterContextDepth &= ~unchecked((int)(0x80000000));
+			}
+		}
+
+		[NotNull]
+		public PredictionContext GetContext()
+		{
+			return context;
+		}
+
+		public virtual void SetContext(PredictionContext context)
+		{
+			this.context = context;
+		}
+
+		public bool GetReachesIntoOuterContext()
+		{
+			return GetOuterContextDepth() != 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.
+		/// 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
+		/// </remarks>
+		public int GetOuterContextDepth()
+		{
+			return ((int)(((uint)altAndOuterContextDepth) >> 24)) & unchecked((int)(0x7F));
+		}
+
+		public virtual void SetOuterContextDepth(int outerContextDepth)
+		{
+			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 int GetActionIndex()
+		{
+			return -1;
+		}
+
+		[NotNull]
+		public virtual SemanticContext GetSemanticContext()
+		{
+			return SemanticContext.None;
+		}
+
+		public Antlr4.Runtime.Atn.ATNConfig Clone()
+		{
+			return Transform(this.GetState());
+		}
+
+		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state)
+		{
+			return Transform(state, this.context, this.GetSemanticContext(), this.GetActionIndex
+				());
+		}
+
+		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, SemanticContext semanticContext
+			)
+		{
+			return Transform(state, this.context, semanticContext, this.GetActionIndex());
+		}
+
+		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context
+			)
+		{
+			return Transform(state, context, this.GetSemanticContext(), this.GetActionIndex()
+				);
+		}
+
+		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, int actionIndex)
+		{
+			return Transform(state, context, this.GetSemanticContext(), actionIndex);
+		}
+
+		private Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext 
+			context, SemanticContext semanticContext, int actionIndex)
+		{
+			if (semanticContext != SemanticContext.None)
+			{
+				if (actionIndex != -1)
+				{
+					return new ATNConfig.ActionSemanticContextATNConfig(actionIndex, semanticContext, 
+						this, state, context);
+				}
+				else
+				{
+					return new ATNConfig.SemanticContextATNConfig(semanticContext, this, state, context
+						);
+				}
+			}
+			else
+			{
+				if (actionIndex != -1)
+				{
+					return new ATNConfig.ActionATNConfig(actionIndex, this, state, context);
+				}
+				else
+				{
+					return new Antlr4.Runtime.Atn.ATNConfig(this, state, context);
+				}
+			}
+		}
+
+		public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(int context, PredictionContextCache
+			 contextCache)
+		{
+			PredictionContext appendedContext = GetContext().AppendContext(context, contextCache
+				);
+			Antlr4.Runtime.Atn.ATNConfig result = Transform(GetState(), appendedContext);
+			return result;
+		}
+
+		public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(PredictionContext context
+			, PredictionContextCache contextCache)
+		{
+			PredictionContext appendedContext = GetContext().AppendContext(context, contextCache
+				);
+			Antlr4.Runtime.Atn.ATNConfig result = Transform(GetState(), appendedContext);
+			return result;
+		}
+
+		public virtual bool Contains(Antlr4.Runtime.Atn.ATNConfig subconfig)
+		{
+			if (this.GetState().stateNumber != subconfig.GetState().stateNumber || this.GetAlt
+				() != subconfig.GetAlt() || !this.GetSemanticContext().Equals(subconfig.GetSemanticContext
+				()))
+			{
+				return false;
+			}
+			Deque<PredictionContext> leftWorkList = new ArrayDeque<PredictionContext>();
+			Deque<PredictionContext> rightWorkList = new ArrayDeque<PredictionContext>();
+			leftWorkList.AddItem(GetContext());
+			rightWorkList.AddItem(subconfig.GetContext());
+			while (!leftWorkList.IsEmpty())
+			{
+				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;
+		}
+
+		/// <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.GetState().stateNumber == other.GetState().stateNumber && this.GetAlt
+				() == other.GetAlt() && this.GetReachesIntoOuterContext() == other.GetReachesIntoOuterContext
+				() && this.GetContext().Equals(other.GetContext()) && this.GetSemanticContext().
+				Equals(other.GetSemanticContext()) && this.GetActionIndex() == other.GetActionIndex
+				();
+		}
+
+		public override int GetHashCode()
+		{
+			int hashCode = 7;
+			hashCode = 5 * hashCode + GetState().stateNumber;
+			hashCode = 5 * hashCode + GetAlt();
+			hashCode = 5 * hashCode + (GetReachesIntoOuterContext() ? 1 : 0);
+			hashCode = 5 * hashCode + (GetContext() != null ? GetContext().GetHashCode() : 0);
+			hashCode = 5 * hashCode + GetSemanticContext().GetHashCode();
+			return hashCode;
+		}
+
+		public virtual string ToDotString()
+		{
+			StringBuilder builder = new StringBuilder();
+			builder.Append("digraph G {\n");
+			builder.Append("rankdir=LR;\n");
+			IDictionary<PredictionContext, PredictionContext> visited = new IdentityHashMap<PredictionContext
+				, PredictionContext>();
+			Deque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
+			workList.AddItem(GetContext());
+			visited.Put(GetContext(), GetContext());
+			while (!workList.IsEmpty())
+			{
+				PredictionContext current = workList.Pop();
+				for (int i = 0; i < current.Size(); i++)
+				{
+					builder.Append("  s").Append(Sharpen.Runtime.IdentityHashCode(current));
+					builder.Append("->");
+					builder.Append("s").Append(Sharpen.Runtime.IdentityHashCode(current.GetParent(i))
+						);
+					builder.Append("[label=\"").Append(current.GetReturnState(i)).Append("\"];\n");
+					if (visited.Put(current.GetParent(i), current.GetParent(i)) == null)
+					{
+						workList.Push(current.GetParent(i));
+					}
+				}
+			}
+			builder.Append("}\n");
+			return builder.ToString();
+		}
+
+		public override string ToString()
+		{
+			return ToString(null, true, false);
+		}
+
+		public virtual string ToString<_T0>(Recognizer<_T0> recog, bool showAlt)
+		{
+			return ToString(recog, showAlt, true);
+		}
+
+		public virtual string ToString<_T0>(Recognizer<_T0> 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 = GetContext().ToStrings(recog, this.GetState().stateNumber);
+			}
+			else
+			{
+				contexts = new string[] { "?" };
+			}
+			bool first = true;
+			foreach (string contextDesc in contexts)
+			{
+				if (first)
+				{
+					first = false;
+				}
+				else
+				{
+					buf.Append(", ");
+				}
+				buf.Append('(');
+				buf.Append(GetState());
+				if (showAlt)
+				{
+					buf.Append(",");
+					buf.Append(GetAlt());
+				}
+				if (GetContext() != null)
+				{
+					buf.Append(",");
+					buf.Append(contextDesc);
+				}
+				if (GetSemanticContext() != null && GetSemanticContext() != SemanticContext.None)
+				{
+					buf.Append(",");
+					buf.Append(GetSemanticContext());
+				}
+				if (GetReachesIntoOuterContext())
+				{
+					buf.Append(",up=").Append(GetOuterContextDepth());
+				}
+				buf.Append(')');
+			}
+			return buf.ToString();
+		}
+
+		private class SemanticContextATNConfig : ATNConfig
+		{
+			[NotNull]
+			private readonly SemanticContext semanticContext;
+
+			public SemanticContextATNConfig(SemanticContext semanticContext, ATNState state, 
+				int alt, PredictionContext context) : base(state, alt, context)
+			{
+				this.semanticContext = semanticContext;
+			}
+
+			public SemanticContextATNConfig(SemanticContext semanticContext, ATNConfig c, ATNState
+				 state, PredictionContext context) : base(c, state, context)
+			{
+				this.semanticContext = semanticContext;
+			}
+
+			public override SemanticContext GetSemanticContext()
+			{
+				return semanticContext;
+			}
+		}
+
+		private class ActionATNConfig : ATNConfig
+		{
+			private readonly int actionIndex;
+
+			public ActionATNConfig(int actionIndex, ATNState state, int alt, PredictionContext
+				 context) : base(state, alt, context)
+			{
+				this.actionIndex = actionIndex;
+			}
+
+			protected internal ActionATNConfig(int actionIndex, ATNConfig c, ATNState state, 
+				PredictionContext context) : base(c, state, context)
+			{
+				if (c.GetSemanticContext() != SemanticContext.None)
+				{
+					throw new NotSupportedException();
+				}
+				this.actionIndex = actionIndex;
+			}
+
+			public override int GetActionIndex()
+			{
+				return actionIndex;
+			}
+		}
+
+		private class ActionSemanticContextATNConfig : ATNConfig.SemanticContextATNConfig
+		{
+			private readonly int actionIndex;
+
+			public ActionSemanticContextATNConfig(int actionIndex, SemanticContext semanticContext
+				, ATNState state, int alt, PredictionContext context) : base(semanticContext, state
+				, alt, context)
+			{
+				this.actionIndex = actionIndex;
+			}
+
+			public ActionSemanticContextATNConfig(int actionIndex, SemanticContext semanticContext
+				, ATNConfig c, ATNState state, PredictionContext context) : base(semanticContext
+				, c, state, context)
+			{
+				this.actionIndex = actionIndex;
+			}
+
+			public override int GetActionIndex()
+			{
+				return actionIndex;
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/ATNConfigSet.cs b/Antlr4.Runtime/Atn/ATNConfigSet.cs
new file mode 100644
index 000000000..087d11f79
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ATNConfigSet.cs
@@ -0,0 +1,692 @@
+/*
+ * [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.Atn;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <author>Sam Harwell</author>
+	public class ATNConfigSet : ICollection<ATNConfig>
+	{
+		/// <summary>
+		/// This maps (state, alt) -&gt; merged
+		/// <see cref="ATNConfig">ATNConfig</see>
+		/// . The key does not account for
+		/// the
+		/// <see cref="ATNConfig.GetSemanticContext()">ATNConfig.GetSemanticContext()</see>
+		/// of the value, which is only a problem if a single
+		/// <code>ATNConfigSet</code>
+		/// 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">unmerged</see>
+		/// .
+		/// <p>
+		/// This map is only used for optimizing the process of adding configs to the set,
+		/// and is
+		/// <code>null</code>
+		/// 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">mergedConfigs</see>
+		/// 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
+		/// <code>null</code>
+		/// for read-only sets stored in the DFA.
+		/// </summary>
+		private readonly AList<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 AList<ATNConfig> configs;
+
+		private int uniqueAlt;
+
+		private BitSet conflictingAlts;
+
+		private bool hasSemanticContext;
+
+		private bool dipsIntoOuterContext;
+
+		/// <summary>
+		/// When
+		/// <code>true</code>
+		/// , 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)
+		/// 	">ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache)
+		/// 	</see>
+		/// from pursuing the global FOLLOW when a
+		/// rule stop state is reached with an empty prediction context.
+		/// <p>
+		/// Note:
+		/// <code>outermostConfigSet</code>
+		/// and
+		/// <see cref="dipsIntoOuterContext">dipsIntoOuterContext</see>
+		/// should never
+		/// be true at the same time.
+		/// </summary>
+		private bool outermostConfigSet;
+
+		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 AList<ATNConfig>();
+			this.configs = new AList<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 = (Dictionary<long, ATNConfig>)set.mergedConfigs.Clone();
+					this.unmerged = (AList<ATNConfig>)set.unmerged.Clone();
+				}
+				else
+				{
+					this.mergedConfigs = new Dictionary<long, ATNConfig>(set.configs.Count);
+					this.unmerged = new AList<ATNConfig>();
+				}
+			}
+			this.configs = (AList<ATNConfig>)set.configs.Clone();
+			this.dipsIntoOuterContext = set.dipsIntoOuterContext;
+			this.hasSemanticContext = set.hasSemanticContext;
+			this.outermostConfigSet = set.outermostConfigSet;
+			if (@readonly || !set.IsReadOnly())
+			{
+				this.uniqueAlt = set.uniqueAlt;
+				this.conflictingAlts = set.conflictingAlts;
+			}
+		}
+
+		// if (!readonly && set.isReadOnly()) -> addAll is called from clone()
+		/// <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 GetRepresentedAlternatives()
+		{
+			if (conflictingAlts != null)
+			{
+				return (BitSet)conflictingAlts.Clone();
+			}
+			BitSet alts = new BitSet();
+			foreach (ATNConfig config in this)
+			{
+				alts.Set(config.GetAlt());
+			}
+			return alts;
+		}
+
+		public bool IsReadOnly()
+		{
+			return mergedConfigs == null;
+		}
+
+		public void StripHiddenConfigs()
+		{
+			EnsureWritable();
+			IEnumerator<KeyValuePair<long, ATNConfig>> iterator = mergedConfigs.EntrySet().GetEnumerator
+				();
+			while (iterator.HasNext())
+			{
+				if (iterator.Next().Value.IsHidden())
+				{
+					iterator.Remove();
+				}
+			}
+			ListIterator<ATNConfig> iterator2 = unmerged.ListIterator();
+			while (iterator2.HasNext())
+			{
+				if (iterator2.Next().IsHidden())
+				{
+					iterator2.Remove();
+				}
+			}
+			iterator2 = configs.ListIterator();
+			while (iterator2.HasNext())
+			{
+				if (iterator2.Next().IsHidden())
+				{
+					iterator2.Remove();
+				}
+			}
+		}
+
+		public virtual bool IsOutermostConfigSet()
+		{
+			return outermostConfigSet;
+		}
+
+		public virtual void SetOutermostConfigSet(bool outermostConfigSet)
+		{
+			if (this.outermostConfigSet && !outermostConfigSet)
+			{
+				throw new InvalidOperationException();
+			}
+			System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+			this.outermostConfigSet = outermostConfigSet;
+		}
+
+		public virtual ICollection<ATNState> GetStates()
+		{
+			ICollection<ATNState> states = new HashSet<ATNState>();
+			foreach (ATNConfig c in this.configs)
+			{
+				states.AddItem(c.GetState());
+			}
+			return states;
+		}
+
+		public virtual void OptimizeConfigs(ATNSimulator interpreter)
+		{
+			if (configs.IsEmpty())
+			{
+				return;
+			}
+			for (int i = 0; i < configs.Count; i++)
+			{
+				ATNConfig config = configs[i];
+				config.SetContext(interpreter.atn.GetCachedContext(config.GetContext()));
+			}
+		}
+
+		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())
+			{
+				Sharpen.Collections.AddAll(copy, this.configs);
+			}
+			return copy;
+		}
+
+		public virtual int Count
+		{
+			get
+			{
+				return configs.Count;
+			}
+		}
+
+		public virtual bool IsEmpty()
+		{
+			return configs.IsEmpty();
+		}
+
+		public virtual bool Contains(object o)
+		{
+			if (!(o is ATNConfig))
+			{
+				return false;
+			}
+			ATNConfig config = (ATNConfig)o;
+			long configKey = GetKey(config);
+			ATNConfig mergedConfig = mergedConfigs.Get(configKey);
+			if (mergedConfig != null && 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 new ATNConfigSet.ATNConfigSetIterator(this);
+		}
+
+		public virtual object[] ToArray()
+		{
+			return Sharpen.Collections.ToArray(configs);
+		}
+
+		public virtual T[] ToArray<T>(T[] a)
+		{
+			return Sharpen.Collections.ToArray(configs, a);
+		}
+
+		public virtual bool AddItem(ATNConfig e)
+		{
+			return Add(e, null);
+		}
+
+		public virtual bool Add(ATNConfig e, PredictionContextCache contextCache)
+		{
+			EnsureWritable();
+			System.Diagnostics.Debug.Assert(!outermostConfigSet || !e.GetReachesIntoOuterContext
+				());
+			System.Diagnostics.Debug.Assert(!e.IsHidden());
+			if (contextCache == null)
+			{
+				contextCache = PredictionContextCache.Uncached;
+			}
+			bool addKey;
+			long key = GetKey(e);
+			ATNConfig mergedConfig = mergedConfigs.Get(key);
+			addKey = (mergedConfig == null);
+			if (mergedConfig != null && CanMerge(e, key, mergedConfig))
+			{
+				mergedConfig.SetOuterContextDepth(Math.Max(mergedConfig.GetOuterContextDepth(), e
+					.GetOuterContextDepth()));
+				PredictionContext joined = PredictionContext.Join(mergedConfig.GetContext(), e.GetContext
+					(), contextCache);
+				UpdatePropertiesForMergedConfig(e);
+				if (mergedConfig.GetContext() == joined)
+				{
+					return false;
+				}
+				mergedConfig.SetContext(joined);
+				return true;
+			}
+			for (int i = 0; i < unmerged.Count; i++)
+			{
+				ATNConfig unmergedConfig = unmerged[i];
+				if (CanMerge(e, key, unmergedConfig))
+				{
+					unmergedConfig.SetOuterContextDepth(Math.Max(unmergedConfig.GetOuterContextDepth(
+						), e.GetOuterContextDepth()));
+					PredictionContext joined = PredictionContext.Join(unmergedConfig.GetContext(), e.
+						GetContext(), contextCache);
+					UpdatePropertiesForMergedConfig(e);
+					if (unmergedConfig.GetContext() == joined)
+					{
+						return false;
+					}
+					unmergedConfig.SetContext(joined);
+					if (addKey)
+					{
+						mergedConfigs.Put(key, unmergedConfig);
+						unmerged.Remove(i);
+					}
+					return true;
+				}
+			}
+			configs.AddItem(e);
+			if (addKey)
+			{
+				mergedConfigs.Put(key, e);
+			}
+			else
+			{
+				unmerged.AddItem(e);
+			}
+			UpdatePropertiesForAddedConfig(e);
+			return true;
+		}
+
+		private void UpdatePropertiesForMergedConfig(ATNConfig config)
+		{
+			// merged configs can't change the alt or semantic context
+			dipsIntoOuterContext |= config.GetReachesIntoOuterContext();
+			System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+		}
+
+		private void UpdatePropertiesForAddedConfig(ATNConfig config)
+		{
+			if (configs.Count == 1)
+			{
+				uniqueAlt = config.GetAlt();
+			}
+			else
+			{
+				if (uniqueAlt != config.GetAlt())
+				{
+					uniqueAlt = ATN.InvalidAltNumber;
+				}
+			}
+			hasSemanticContext |= !SemanticContext.None.Equals(config.GetSemanticContext());
+			dipsIntoOuterContext |= config.GetReachesIntoOuterContext();
+			System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+		}
+
+		protected internal virtual bool CanMerge(ATNConfig left, long leftKey, ATNConfig 
+			right)
+		{
+			if (left.GetState().stateNumber != right.GetState().stateNumber)
+			{
+				return false;
+			}
+			if (leftKey != GetKey(right))
+			{
+				return false;
+			}
+			return left.GetSemanticContext().Equals(right.GetSemanticContext());
+		}
+
+		protected internal virtual long GetKey(ATNConfig e)
+		{
+			long key = e.GetState().stateNumber;
+			key = (key << 12) | (e.GetAlt() & unchecked((int)(0xFFF)));
+			return key;
+		}
+
+		public virtual bool Remove(object o)
+		{
+			EnsureWritable();
+			throw new NotSupportedException("Not supported yet.");
+		}
+
+		public virtual bool ContainsAll<_T0>(ICollection<_T0> c)
+		{
+			foreach (object o in c)
+			{
+				if (!(o is ATNConfig))
+				{
+					return false;
+				}
+				if (!Contains((ATNConfig)o))
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+
+		public virtual bool AddAll<_T0>(ICollection<_T0> c) where _T0:ATNConfig
+		{
+			return AddAll(c, null);
+		}
+
+		public virtual bool AddAll<_T0>(ICollection<_T0> c, PredictionContextCache contextCache
+			) where _T0:ATNConfig
+		{
+			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;
+			conflictingAlts = 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(conflictingAlts
+				, other.conflictingAlts) && configs.Equals(other.configs);
+		}
+
+		public override int GetHashCode()
+		{
+			int hashCode = 1;
+			hashCode = 5 * hashCode ^ (outermostConfigSet ? 1 : 0);
+			hashCode = 5 * hashCode ^ configs.GetHashCode();
+			return hashCode;
+		}
+
+		public override string ToString()
+		{
+			return ToString(false);
+		}
+
+		public virtual string ToString(bool showContext)
+		{
+			StringBuilder buf = new StringBuilder();
+			IList<ATNConfig> sortedConfigs = new AList<ATNConfig>(configs);
+			sortedConfigs.Sort(new _IComparer_467());
+			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 (conflictingAlts != null)
+			{
+				buf.Append(",conflictingAlts=").Append(conflictingAlts);
+			}
+			if (dipsIntoOuterContext)
+			{
+				buf.Append(",dipsIntoOuterContext");
+			}
+			return buf.ToString();
+		}
+
+		private sealed class _IComparer_467 : IComparer<ATNConfig>
+		{
+			public _IComparer_467()
+			{
+			}
+
+			public int Compare(ATNConfig o1, ATNConfig o2)
+			{
+				if (o1.GetAlt() != o2.GetAlt())
+				{
+					return o1.GetAlt() - o2.GetAlt();
+				}
+				else
+				{
+					if (o1.GetState().stateNumber != o2.GetState().stateNumber)
+					{
+						return o1.GetState().stateNumber - o2.GetState().stateNumber;
+					}
+					else
+					{
+						return Sharpen.Runtime.CompareOrdinal(o1.GetSemanticContext().ToString(), o2.GetSemanticContext
+							().ToString());
+					}
+				}
+			}
+		}
+
+		public virtual int GetUniqueAlt()
+		{
+			return uniqueAlt;
+		}
+
+		public virtual bool HasSemanticContext()
+		{
+			return hasSemanticContext;
+		}
+
+		public virtual void ClearExplicitSemanticContext()
+		{
+			EnsureWritable();
+			hasSemanticContext = false;
+		}
+
+		public virtual void MarkExplicitSemanticContext()
+		{
+			EnsureWritable();
+			hasSemanticContext = true;
+		}
+
+		public virtual BitSet GetConflictingAlts()
+		{
+			return conflictingAlts;
+		}
+
+		public virtual void SetConflictingAlts(BitSet conflictingAlts)
+		{
+			EnsureWritable();
+			this.conflictingAlts = conflictingAlts;
+		}
+
+		public virtual bool GetDipsIntoOuterContext()
+		{
+			return dipsIntoOuterContext;
+		}
+
+		public virtual ATNConfig Get(int index)
+		{
+			return configs[index];
+		}
+
+		public virtual void Remove(int index)
+		{
+			EnsureWritable();
+			ATNConfig config = configs[index];
+			configs.Remove(config);
+			long key = GetKey(config);
+			if (mergedConfigs.Get(key) == config)
+			{
+				Sharpen.Collections.Remove(mergedConfigs, key);
+			}
+			else
+			{
+				for (int i = 0; i < unmerged.Count; i++)
+				{
+					if (unmerged[i] == config)
+					{
+						unmerged.Remove(i);
+						return;
+					}
+				}
+			}
+		}
+
+		protected internal void EnsureWritable()
+		{
+			if (IsReadOnly())
+			{
+				throw new InvalidOperationException("This ATNConfigSet is read only.");
+			}
+		}
+
+		private sealed class ATNConfigSetIterator : IEnumerator<ATNConfig>
+		{
+			internal int index = -1;
+
+			internal bool removed = false;
+
+			public override bool HasNext()
+			{
+				return this.index + 1 < this._enclosing.configs.Count;
+			}
+
+			public override ATNConfig Next()
+			{
+				if (!this.HasNext())
+				{
+					throw new NoSuchElementException();
+				}
+				this.index++;
+				this.removed = false;
+				return this._enclosing.configs[this.index];
+			}
+
+			public override void Remove()
+			{
+				if (this.removed || this.index < 0 || this.index >= this._enclosing.configs.Count)
+				{
+					throw new InvalidOperationException();
+				}
+				this._enclosing.Remove(this.index);
+				this.removed = true;
+			}
+
+			internal ATNConfigSetIterator(ATNConfigSet _enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly ATNConfigSet _enclosing;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/ATNSimulator.cs b/Antlr4.Runtime/Atn/ATNSimulator.cs
new file mode 100644
index 000000000..afd87248f
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ATNSimulator.cs
@@ -0,0 +1,995 @@
+/*
+ * [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 Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public abstract class ATNSimulator
+	{
+		public static readonly int SerializedVersion;
+
+		static ATNSimulator()
+		{
+			SerializedVersion = 5;
+		}
+
+		public const char RuleVariantDelimiter = '$';
+
+		public static readonly string RuleLfVariantMarker = "$lf$";
+
+		public static readonly string RuleNolfVariantMarker = "$nolf$";
+
+		/// <summary>Must distinguish between missing edge and edge we know leads nowhere</summary>
+		[NotNull]
+		public static readonly DFAState Error;
+
+		[NotNull]
+		public readonly ATN atn;
+
+		static ATNSimulator()
+		{
+			Error = new DFAState(new ATNConfigSet(), 0, 0);
+			Error.stateNumber = int.MaxValue;
+		}
+
+		public ATNSimulator(ATN atn)
+		{
+			this.atn = atn;
+		}
+
+		public abstract void Reset();
+
+		public static ATN Deserialize(char[] data)
+		{
+			return Deserialize(data, true);
+		}
+
+		public static ATN Deserialize(char[] data, bool optimize)
+		{
+			data = data.Clone();
+			// don't adjust the first value since that's the version number
+			for (int i = 1; i < data.Length; i++)
+			{
+				data[i] = (char)(data[i] - 2);
+			}
+			ATN atn = new ATN();
+			IList<IntervalSet> sets = new AList<IntervalSet>();
+			int p = 0;
+			int version = ToInt(data[p++]);
+			if (version != SerializedVersion)
+			{
+				string reason = string.Format("Could not deserialize ATN with version %d (expected %d)."
+					, version, SerializedVersion);
+				throw new NotSupportedException(new InvalidClassException(typeof(ATN).FullName, reason
+					));
+			}
+			atn.grammarType = ToInt(data[p++]);
+			atn.maxTokenType = ToInt(data[p++]);
+			//
+			// STATES
+			//
+			IList<Tuple<LoopEndState, int>> loopBackStateNumbers = new AList<Tuple<LoopEndState
+				, int>>();
+			IList<Tuple<BlockStartState, int>> endStateNumbers = new AList<Tuple<BlockStartState
+				, int>>();
+			int nstates = ToInt(data[p++]);
+			for (int i_1 = 1; i_1 <= nstates; i_1++)
+			{
+				int stype = ToInt(data[p++]);
+				// ignore bad type of states
+				if (stype == ATNState.InvalidType)
+				{
+					atn.AddState(null);
+					continue;
+				}
+				int ruleIndex = ToInt(data[p++]);
+				ATNState s = StateFactory(stype, ruleIndex);
+				if (stype == ATNState.LoopEnd)
+				{
+					// special case
+					int loopBackStateNumber = ToInt(data[p++]);
+					loopBackStateNumbers.AddItem(Tuple.Create((LoopEndState)s, loopBackStateNumber));
+				}
+				else
+				{
+					if (s is BlockStartState)
+					{
+						int endStateNumber = ToInt(data[p++]);
+						endStateNumbers.AddItem(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.GetItem1().loopBackState = atn.states[pair.GetItem2()];
+			}
+			foreach (Tuple<BlockStartState, int> pair_1 in endStateNumbers)
+			{
+				pair_1.GetItem1().endState = (BlockEndState)atn.states[pair_1.GetItem2()];
+			}
+			int numNonGreedyStates = ToInt(data[p++]);
+			for (int i_2 = 0; i_2 < numNonGreedyStates; i_2++)
+			{
+				int stateNumber = ToInt(data[p++]);
+				((DecisionState)atn.states[stateNumber]).nonGreedy = true;
+			}
+			int numSllDecisions = ToInt(data[p++]);
+			for (int i_3 = 0; i_3 < numSllDecisions; i_3++)
+			{
+				int stateNumber = ToInt(data[p++]);
+				((DecisionState)atn.states[stateNumber]).sll = true;
+			}
+			int numPrecedenceStates = ToInt(data[p++]);
+			for (int i_4 = 0; i_4 < numPrecedenceStates; i_4++)
+			{
+				int stateNumber = ToInt(data[p++]);
+				((RuleStartState)atn.states[stateNumber]).isPrecedenceRule = true;
+			}
+			//
+			// RULES
+			//
+			int nrules = ToInt(data[p++]);
+			if (atn.grammarType == ATN.Lexer)
+			{
+				atn.ruleToTokenType = new int[nrules];
+				atn.ruleToActionIndex = new int[nrules];
+			}
+			atn.ruleToStartState = new RuleStartState[nrules];
+			for (int i_5 = 0; i_5 < nrules; i_5++)
+			{
+				int s = ToInt(data[p++]);
+				RuleStartState startState = (RuleStartState)atn.states[s];
+				startState.leftFactored = ToInt(data[p++]) != 0;
+				atn.ruleToStartState[i_5] = startState;
+				if (atn.grammarType == ATN.Lexer)
+				{
+					int tokenType = ToInt(data[p++]);
+					atn.ruleToTokenType[i_5] = tokenType;
+					int actionIndex = ToInt(data[p++]);
+					atn.ruleToActionIndex[i_5] = actionIndex;
+				}
+			}
+			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;
+			}
+			//
+			// MODES
+			//
+			int nmodes = ToInt(data[p++]);
+			for (int i_6 = 0; i_6 < nmodes; i_6++)
+			{
+				int s = ToInt(data[p++]);
+				atn.modeToStartState.AddItem((TokensStartState)atn.states[s]);
+			}
+			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]);
+			}
+			//
+			// SETS
+			//
+			int nsets = ToInt(data[p++]);
+			for (int i_8 = 1; i_8 <= nsets; i_8++)
+			{
+				int nintervals = ToInt(data[p]);
+				p++;
+				IntervalSet set = new IntervalSet();
+				sets.AddItem(set);
+				for (int j = 1; j <= nintervals; j++)
+				{
+					set.Add(ToInt(data[p]), ToInt(data[p + 1]));
+					p += 2;
+				}
+			}
+			//
+			// EDGES
+			//
+			int nedges = ToInt(data[p++]);
+			for (int i_9 = 1; i_9 <= nedges; i_9++)
+			{
+				int src = ToInt(data[p]);
+				int trg = ToInt(data[p + 1]);
+				int ttype = ToInt(data[p + 2]);
+				int arg1 = ToInt(data[p + 3]);
+				int arg2 = ToInt(data[p + 4]);
+				int arg3 = ToInt(data[p + 5]);
+				Transition trans = EdgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
+				//			System.out.println("EDGE "+trans.getClass().getSimpleName()+" "+
+				//							   src+"->"+trg+
+				//					   " "+Transition.serializationNames[ttype]+
+				//					   " "+arg1+","+arg2+","+arg3);
+				ATNState srcState = atn.states[src];
+				srcState.AddTransition(trans);
+				p += 6;
+			}
+			// edges for rule stop states can be derived, so they aren't serialized
+			foreach (ATNState state_1 in atn.states)
+			{
+				bool returningToLeftFactored = state_1.ruleIndex >= 0 && atn.ruleToStartState[state_1
+					.ruleIndex].leftFactored;
+				for (int i_10 = 0; i_10 < state_1.GetNumberOfTransitions(); i_10++)
+				{
+					Transition t = state_1.Transition(i_10);
+					if (!(t is RuleTransition))
+					{
+						continue;
+					}
+					RuleTransition ruleTransition = (RuleTransition)t;
+					bool returningFromLeftFactored = atn.ruleToStartState[ruleTransition.target.ruleIndex
+						].leftFactored;
+					if (!returningFromLeftFactored && returningToLeftFactored)
+					{
+						continue;
+					}
+					atn.ruleToStopState[ruleTransition.target.ruleIndex].AddTransition(new EpsilonTransition
+						(ruleTransition.followState));
+				}
+			}
+			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;
+				}
+				if (state_2 is PlusLoopbackState)
+				{
+					PlusLoopbackState loopbackState = (PlusLoopbackState)state_2;
+					for (int i_10 = 0; i_10 < loopbackState.GetNumberOfTransitions(); 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.GetNumberOfTransitions(); i_10++)
+						{
+							ATNState target = loopbackState.Transition(i_10).target;
+							if (target is StarLoopEntryState)
+							{
+								((StarLoopEntryState)target).loopBackState = loopbackState;
+							}
+						}
+					}
+				}
+			}
+			//
+			// DECISIONS
+			//
+			int ndecisions = ToInt(data[p++]);
+			for (int i_11 = 1; i_11 <= ndecisions; i_11++)
+			{
+				int s = ToInt(data[p++]);
+				DecisionState decState = (DecisionState)atn.states[s];
+				atn.decisionToState.AddItem(decState);
+				decState.decision = i_11 - 1;
+			}
+			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);
+			}
+			if (optimize)
+			{
+				while (true)
+				{
+					int optimizationCount = 0;
+					optimizationCount += InlineSetRules(atn);
+					optimizationCount += CombineChainedEpsilons(atn);
+					bool preserveOrder = atn.grammarType == ATN.Lexer;
+					optimizationCount += OptimizeSets(atn, preserveOrder);
+					if (optimizationCount == 0)
+					{
+						break;
+					}
+				}
+			}
+			IdentifyTailCalls(atn);
+			VerifyATN(atn);
+			return atn;
+		}
+
+		private static void VerifyATN(ATN atn)
+		{
+			// verify assumptions
+			foreach (ATNState state in atn.states)
+			{
+				if (state == null)
+				{
+					continue;
+				}
+				CheckCondition(state.OnlyHasEpsilonTransitions() || state.GetNumberOfTransitions(
+					) <= 1);
+				if (state is PlusBlockStartState)
+				{
+					CheckCondition(((PlusBlockStartState)state).loopBackState != null);
+				}
+				if (state is StarLoopEntryState)
+				{
+					StarLoopEntryState starLoopEntryState = (StarLoopEntryState)state;
+					CheckCondition(starLoopEntryState.loopBackState != null);
+					CheckCondition(starLoopEntryState.GetNumberOfTransitions() == 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.GetNumberOfTransitions() == 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.GetNumberOfTransitions() <= 1 || decisionState.decision
+						 >= 0);
+				}
+				else
+				{
+					CheckCondition(state.GetNumberOfTransitions() <= 1 || state is RuleStopState);
+				}
+			}
+		}
+
+		public static void CheckCondition(bool condition)
+		{
+			CheckCondition(condition, null);
+		}
+
+		public static 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.GetNumberOfOptimizedTransitions
+					() == 1 && middleState.GetOptimizedTransition(0).GetSerializationType() == Transition
+					.Epsilon)
+				{
+					middleState = middleState.GetOptimizedTransition(0).target;
+				}
+				if (middleState.GetNumberOfOptimizedTransitions() != 1)
+				{
+					continue;
+				}
+				Transition matchTransition = middleState.GetOptimizedTransition(0);
+				ATNState matchTarget = matchTransition.target;
+				if (matchTransition.IsEpsilon() || !matchTarget.OnlyHasEpsilonTransitions() || matchTarget
+					.GetNumberOfOptimizedTransitions() != 1 || !(matchTarget.GetOptimizedTransition(
+					0).target is RuleStopState))
+				{
+					continue;
+				}
+				switch (matchTransition.GetSerializationType())
+				{
+					case Transition.Atom:
+					case Transition.Range:
+					case Transition.Set:
+					{
+						ruleToInlineTransition[i] = matchTransition;
+						break;
+					}
+
+					case Transition.NotSet:
+					case Transition.Wildcard:
+					{
+						// not implemented yet
+						continue;
+						goto default;
+					}
+
+					default:
+					{
+						continue;
+						break;
+					}
+				}
+			}
+			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.GetNumberOfOptimizedTransitions(); i_1++)
+				{
+					Transition transition = state.GetOptimizedTransition(i_1);
+					if (!(transition is RuleTransition))
+					{
+						if (optimizedTransitions != null)
+						{
+							optimizedTransitions.AddItem(transition);
+						}
+						continue;
+					}
+					RuleTransition ruleTransition = (RuleTransition)transition;
+					Transition effective = ruleToInlineTransition[ruleTransition.target.ruleIndex];
+					if (effective == null)
+					{
+						if (optimizedTransitions != null)
+						{
+							optimizedTransitions.AddItem(transition);
+						}
+						continue;
+					}
+					if (optimizedTransitions == null)
+					{
+						optimizedTransitions = new AList<Transition>();
+						for (int j = 0; j < i_1; j++)
+						{
+							optimizedTransitions.AddItem(state.GetOptimizedTransition(i_1));
+						}
+					}
+					inlinedCalls++;
+					ATNState target = ruleTransition.followState;
+					ATNState intermediateState = new BasicState();
+					intermediateState.SetRuleIndex(target.ruleIndex);
+					atn.AddState(intermediateState);
+					optimizedTransitions.AddItem(new EpsilonTransition(intermediateState));
+					switch (effective.GetSerializationType())
+					{
+						case Transition.Atom:
+						{
+							intermediateState.AddTransition(new AtomTransition(target, ((AtomTransition)effective
+								).label));
+							break;
+						}
+
+						case Transition.Range:
+						{
+							intermediateState.AddTransition(new RangeTransition(target, ((RangeTransition)effective
+								).from, ((RangeTransition)effective).to));
+							break;
+						}
+
+						case Transition.Set:
+						{
+							intermediateState.AddTransition(new SetTransition(target, effective.Label()));
+							break;
+						}
+
+						default:
+						{
+							throw new NotSupportedException();
+						}
+					}
+				}
+				if (optimizedTransitions != null)
+				{
+					if (state.IsOptimized())
+					{
+						while (state.GetNumberOfOptimizedTransitions() > 0)
+						{
+							state.RemoveOptimizedTransition(state.GetNumberOfOptimizedTransitions() - 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.GetNumberOfOptimizedTransitions(); i++)
+				{
+					Transition transition = state.GetOptimizedTransition(i);
+					ATNState intermediate = transition.target;
+					if (transition.GetSerializationType() != Transition.Epsilon || intermediate.GetStateType
+						() != ATNState.Basic || !intermediate.OnlyHasEpsilonTransitions())
+					{
+						if (optimizedTransitions != null)
+						{
+							optimizedTransitions.AddItem(transition);
+						}
+						goto nextTransition_continue;
+					}
+					for (int j = 0; j < intermediate.GetNumberOfOptimizedTransitions(); j++)
+					{
+						if (intermediate.GetOptimizedTransition(j).GetSerializationType() != Transition.Epsilon)
+						{
+							if (optimizedTransitions != null)
+							{
+								optimizedTransitions.AddItem(transition);
+							}
+							goto nextTransition_continue;
+						}
+					}
+					removedEdges++;
+					if (optimizedTransitions == null)
+					{
+						optimizedTransitions = new AList<Transition>();
+						for (int j_1 = 0; j_1 < i; j_1++)
+						{
+							optimizedTransitions.AddItem(state.GetOptimizedTransition(j_1));
+						}
+					}
+					for (int j_2 = 0; j_2 < intermediate.GetNumberOfOptimizedTransitions(); j_2++)
+					{
+						ATNState target = intermediate.GetOptimizedTransition(j_2).target;
+						optimizedTransitions.AddItem(new EpsilonTransition(target));
+					}
+nextTransition_continue: ;
+				}
+nextTransition_break: ;
+				if (optimizedTransitions != null)
+				{
+					if (state.IsOptimized())
+					{
+						while (state.GetNumberOfOptimizedTransitions() > 0)
+						{
+							state.RemoveOptimizedTransition(state.GetNumberOfOptimizedTransitions() - 1);
+						}
+					}
+					foreach (Transition transition in optimizedTransitions)
+					{
+						state.AddOptimizedTransition(transition);
+					}
+				}
+			}
+nextState_break: ;
+			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.GetNumberOfOptimizedTransitions(); i++)
+				{
+					Transition epsTransition = decision.GetOptimizedTransition(i);
+					if (!(epsTransition is EpsilonTransition))
+					{
+						continue;
+					}
+					if (epsTransition.target.GetNumberOfOptimizedTransitions() != 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.Size() <= 1)
+				{
+					continue;
+				}
+				IList<Transition> optimizedTransitions = new AList<Transition>();
+				for (int i_1 = 0; i_1 < decision.GetNumberOfOptimizedTransitions(); i_1++)
+				{
+					if (!setTransitions.Contains(i_1))
+					{
+						optimizedTransitions.AddItem(decision.GetOptimizedTransition(i_1));
+					}
+				}
+				ATNState blockEndState = decision.GetOptimizedTransition(setTransitions.GetMinElement
+					()).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.Size() == 1)
+					{
+						newTransition = new AtomTransition(blockEndState, matchSet.GetMinElement());
+					}
+					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.AddItem(new EpsilonTransition(setOptimizedState));
+				removedPaths += decision.GetNumberOfOptimizedTransitions() - optimizedTransitions
+					.Count;
+				if (decision.IsOptimized())
+				{
+					while (decision.GetNumberOfOptimizedTransitions() > 0)
+					{
+						decision.RemoveOptimizedTransition(decision.GetNumberOfOptimizedTransitions() - 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);
+			Deque<ATNState> worklist = new ArrayDeque<ATNState>();
+			worklist.AddItem(transition.followState);
+			while (!worklist.IsEmpty())
+			{
+				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.GetSerializationType() != Transition.Epsilon)
+					{
+						return false;
+					}
+					worklist.AddItem(t.target);
+				}
+			}
+			return true;
+		}
+
+		public static int ToInt(char c)
+		{
+			return c == 65535 ? -1 : c;
+		}
+
+		[NotNull]
+		public static Transition EdgeFactory(ATN atn, int type, int src, int trg, int arg1
+			, int arg2, int arg3, IList<IntervalSet> sets)
+		{
+			ATNState target = atn.states[trg];
+			switch (type)
+			{
+				case Transition.Epsilon:
+				{
+					return new EpsilonTransition(target);
+				}
+
+				case Transition.Range:
+				{
+					return new RangeTransition(target, arg1, arg2);
+				}
+
+				case Transition.Rule:
+				{
+					RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3
+						, target);
+					return rt;
+				}
+
+				case Transition.Predicate:
+				{
+					PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0);
+					return pt;
+				}
+
+				case Transition.Precedence:
+				{
+					return new PrecedencePredicateTransition(target, arg1);
+				}
+
+				case Transition.Atom:
+				{
+					return new AtomTransition(target, arg1);
+				}
+
+				case Transition.Action:
+				{
+					ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0);
+					return a;
+				}
+
+				case Transition.Set:
+				{
+					return new SetTransition(target, sets[arg1]);
+				}
+
+				case Transition.NotSet:
+				{
+					return new NotSetTransition(target, sets[arg1]);
+				}
+
+				case Transition.Wildcard:
+				{
+					return new WildcardTransition(target);
+				}
+			}
+			throw new ArgumentException("The specified transition type is not valid.");
+		}
+
+		public static ATNState StateFactory(int type, int ruleIndex)
+		{
+			ATNState s;
+			switch (type)
+			{
+				case ATNState.InvalidType:
+				{
+					return null;
+				}
+
+				case ATNState.Basic:
+				{
+					s = new BasicState();
+					break;
+				}
+
+				case ATNState.RuleStart:
+				{
+					s = new RuleStartState();
+					break;
+				}
+
+				case ATNState.BlockStart:
+				{
+					s = new BasicBlockStartState();
+					break;
+				}
+
+				case ATNState.PlusBlockStart:
+				{
+					s = new PlusBlockStartState();
+					break;
+				}
+
+				case ATNState.StarBlockStart:
+				{
+					s = new StarBlockStartState();
+					break;
+				}
+
+				case ATNState.TokenStart:
+				{
+					s = new TokensStartState();
+					break;
+				}
+
+				case ATNState.RuleStop:
+				{
+					s = new RuleStopState();
+					break;
+				}
+
+				case ATNState.BlockEnd:
+				{
+					s = new BlockEndState();
+					break;
+				}
+
+				case ATNState.StarLoopBack:
+				{
+					s = new StarLoopbackState();
+					break;
+				}
+
+				case ATNState.StarLoopEntry:
+				{
+					s = new StarLoopEntryState();
+					break;
+				}
+
+				case ATNState.PlusLoopBack:
+				{
+					s = new PlusLoopbackState();
+					break;
+				}
+
+				case ATNState.LoopEnd:
+				{
+					s = new LoopEndState();
+					break;
+				}
+
+				default:
+				{
+					string message = string.Format("The specified state type %d is not valid.", type);
+					throw new ArgumentException(message);
+				}
+			}
+			s.ruleIndex = ruleIndex;
+			return s;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/ATNState.cs b/Antlr4.Runtime/Atn/ATNState.cs
new file mode 100644
index 000000000..7bbf6ac39
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ATNState.cs
@@ -0,0 +1,304 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>
+	/// The following images show the relation of states and
+	/// <see cref="transitions">transitions</see>
+	/// for various grammar constructs.
+	/// <ul>
+	/// <li>Solid edges marked with an &#0949; indicate a required
+	/// <see cref="EpsilonTransition">EpsilonTransition</see>
+	/// .</li>
+	/// <li>Dashed edges indicate locations where any transition derived from
+	/// <see cref="Transition">Transition</see>
+	/// might appear.</li>
+	/// <li>Dashed nodes are place holders for either a sequence of linked
+	/// <see cref="BasicState">BasicState</see>
+	/// 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>...</code>
+	/// support
+	/// any number of alternatives (one or more). Nodes without the
+	/// <code>...</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>(...)*</code>
+	/// </h3>
+	/// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+	/// <h3>Greedy Positive Closure:
+	/// <code>(...)+</code>
+	/// </h3>
+	/// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+	/// <h3>Greedy Optional:
+	/// <code>(...)?</code>
+	/// </h3>
+	/// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+	/// <h2>Non-Greedy Loops</h2>
+	/// <h3>Non-Greedy Closure:
+	/// <code>(...)*?</code>
+	/// </h3>
+	/// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+	/// <h3>Non-Greedy Positive Closure:
+	/// <code>(...)+?</code>
+	/// </h3>
+	/// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+	/// <h3>Non-Greedy Optional:
+	/// <code>(...)??</code>
+	/// </h3>
+	/// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+	/// </summary>
+	public abstract class ATNState
+	{
+		public const int InitialNumTransitions = 4;
+
+		public const int InvalidType = 0;
+
+		public const int Basic = 1;
+
+		public const int RuleStart = 2;
+
+		public const int BlockStart = 3;
+
+		public const int PlusBlockStart = 4;
+
+		public const int StarBlockStart = 5;
+
+		public const int TokenStart = 6;
+
+		public const int RuleStop = 7;
+
+		public const int BlockEnd = 8;
+
+		public const int StarLoopBack = 9;
+
+		public const int StarLoopEntry = 10;
+
+		public const int PlusLoopBack = 11;
+
+		public const int LoopEnd = 12;
+
+		public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList
+			(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 IList<Antlr4.Runtime.Atn.Transition> transitions = new 
+			AList<Antlr4.Runtime.Atn.Transition>(InitialNumTransitions);
+
+		protected internal IList<Antlr4.Runtime.Atn.Transition> optimizedTransitions;
+
+		/// <summary>Used to cache lookahead during parsing, not used during construction</summary>
+		public IntervalSet nextTokenWithinRule;
+
+		// constants for serialization
+		// at runtime, we don't have Rule objects
+		/// <summary>Gets the state number.</summary>
+		/// <remarks>Gets the state number.</remarks>
+		/// <returns>the state number</returns>
+		public int GetStateNumber()
+		{
+			return stateNumber;
+		}
+
+		/// <summary>
+		/// For all states except
+		/// <see cref="RuleStopState">RuleStopState</see>
+		/// , this returns the state
+		/// number. Returns -1 for stop states.
+		/// </summary>
+		/// <returns>
+		/// -1 for
+		/// <see cref="RuleStopState">RuleStopState</see>
+		/// , otherwise the state number
+		/// </returns>
+		public virtual int GetNonStopStateNumber()
+		{
+			return GetStateNumber();
+		}
+
+		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()
+		{
+			return false;
+		}
+
+		public override string ToString()
+		{
+			return stateNumber.ToString();
+		}
+
+		public virtual Antlr4.Runtime.Atn.Transition[] GetTransitions()
+		{
+			return Sharpen.Collections.ToArray(transitions, new Antlr4.Runtime.Atn.Transition
+				[transitions.Count]);
+		}
+
+		public virtual int GetNumberOfTransitions()
+		{
+			return transitions.Count;
+		}
+
+		public virtual void AddTransition(Antlr4.Runtime.Atn.Transition e)
+		{
+			if (transitions.IsEmpty())
+			{
+				epsilonOnlyTransitions = e.IsEpsilon();
+			}
+			else
+			{
+				if (epsilonOnlyTransitions != e.IsEpsilon())
+				{
+					System.Console.Error.Format("ATN state %d has both epsilon and non-epsilon transitions.\n"
+						, stateNumber);
+					epsilonOnlyTransitions = false;
+				}
+			}
+			transitions.AddItem(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.Set(i, e);
+		}
+
+		public virtual Antlr4.Runtime.Atn.Transition RemoveTransition(int index)
+		{
+			return transitions.Remove(index);
+		}
+
+		public abstract int GetStateType();
+
+		public bool OnlyHasEpsilonTransitions()
+		{
+			return epsilonOnlyTransitions;
+		}
+
+		public virtual void SetRuleIndex(int ruleIndex)
+		{
+			this.ruleIndex = ruleIndex;
+		}
+
+		public virtual bool IsOptimized()
+		{
+			return optimizedTransitions != transitions;
+		}
+
+		public virtual int GetNumberOfOptimizedTransitions()
+		{
+			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 AList<Antlr4.Runtime.Atn.Transition>();
+			}
+			optimizedTransitions.AddItem(e);
+		}
+
+		public virtual void SetOptimizedTransition(int i, Antlr4.Runtime.Atn.Transition e
+			)
+		{
+			if (!IsOptimized())
+			{
+				throw new InvalidOperationException();
+			}
+			optimizedTransitions.Set(i, e);
+		}
+
+		public virtual void RemoveOptimizedTransition(int i)
+		{
+			if (!IsOptimized())
+			{
+				throw new InvalidOperationException();
+			}
+			optimizedTransitions.Remove(i);
+		}
+
+		public ATNState()
+		{
+			optimizedTransitions = transitions;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs b/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
new file mode 100644
index 000000000..c8c7fe795
--- /dev/null
+++ b/Antlr4.Runtime/Atn/AbstractPredicateTransition.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.Atn;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <author>Sam Harwell</author>
+	public abstract class AbstractPredicateTransition : Transition
+	{
+		protected internal AbstractPredicateTransition(ATNState target) : base(target)
+		{
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/ActionTransition.cs b/Antlr4.Runtime/Atn/ActionTransition.cs
new file mode 100644
index 000000000..b21d4e5d8
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ActionTransition.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.Atn;
+using 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 int GetSerializationType()
+		{
+			return Action;
+		}
+
+		public override bool IsEpsilon()
+		{
+			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/Antlr4.Runtime/Atn/ArrayPredictionContext.cs b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
new file mode 100644
index 000000000..a7ff42864
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ArrayPredictionContext.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 System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public class ArrayPredictionContext : PredictionContext
+	{
+		[NotNull]
+		public readonly PredictionContext[] parents;
+
+		[NotNull]
+		public readonly int[] returnStates;
+
+		internal ArrayPredictionContext(PredictionContext[] parents, int[] returnStates) : 
+			base(CalculateHashCode(CalculateParentHashCode(parents), CalculateReturnStatesHashCode
+			(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()
+		{
+			return returnStates.Length;
+		}
+
+		public override bool IsEmpty()
+		{
+			return false;
+		}
+
+		public override bool HasEmpty()
+		{
+			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 = visited.Get(context);
+			if (result == null)
+			{
+				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.Put(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, ICollection<
+			PredictionContextCache.IdentityCommutativePredictionContextOperands> visited)
+		{
+			Deque<PredictionContext> selfWorkList = new ArrayDeque<PredictionContext>();
+			Deque<PredictionContext> otherWorkList = new ArrayDeque<PredictionContext>();
+			selfWorkList.Push(this);
+			otherWorkList.Push(other);
+			while (!selfWorkList.IsEmpty())
+			{
+				PredictionContextCache.IdentityCommutativePredictionContextOperands operands = new 
+					PredictionContextCache.IdentityCommutativePredictionContextOperands(selfWorkList
+					.Pop(), otherWorkList.Pop());
+				if (!visited.AddItem(operands))
+				{
+					continue;
+				}
+				int selfSize = operands.GetX().Size();
+				if (selfSize == 0)
+				{
+					if (!operands.GetX().Equals(operands.GetY()))
+					{
+						return false;
+					}
+					continue;
+				}
+				int otherSize = operands.GetY().Size();
+				if (selfSize != otherSize)
+				{
+					return false;
+				}
+				for (int i = 0; i < selfSize; i++)
+				{
+					if (operands.GetX().GetReturnState(i) != operands.GetY().GetReturnState(i))
+					{
+						return false;
+					}
+					PredictionContext selfParent = operands.GetX().GetParent(i);
+					PredictionContext otherParent = operands.GetY().GetParent(i);
+					if (selfParent.GetHashCode() != otherParent.GetHashCode())
+					{
+						return false;
+					}
+					if (selfParent != otherParent)
+					{
+						selfWorkList.Push(selfParent);
+						otherWorkList.Push(otherParent);
+					}
+				}
+			}
+			return true;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/AtomTransition.cs b/Antlr4.Runtime/Atn/AtomTransition.cs
new file mode 100644
index 000000000..8b496c3b1
--- /dev/null
+++ b/Antlr4.Runtime/Atn/AtomTransition.cs
@@ -0,0 +1,70 @@
+/*
+ * [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 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 label;
+
+		public AtomTransition(ATNState target, int label) : base(target)
+		{
+			this.label = label;
+		}
+
+		public override int GetSerializationType()
+		{
+			return Atom;
+		}
+
+		[NotNull]
+		public override IntervalSet Label()
+		{
+			return IntervalSet.Of(label);
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return label == symbol;
+		}
+
+		[NotNull]
+		public override string ToString()
+		{
+			return label.ToString();
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/BasicBlockStartState.cs b/Antlr4.Runtime/Atn/BasicBlockStartState.cs
new file mode 100644
index 000000000..8be4d5591
--- /dev/null
+++ b/Antlr4.Runtime/Atn/BasicBlockStartState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <author>Sam Harwell</author>
+	public sealed class BasicBlockStartState : BlockStartState
+	{
+		public override int GetStateType()
+		{
+			return BlockStart;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/BasicState.cs b/Antlr4.Runtime/Atn/BasicState.cs
new file mode 100644
index 000000000..c405eab44
--- /dev/null
+++ b/Antlr4.Runtime/Atn/BasicState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <author>Sam Harwell</author>
+	public sealed class BasicState : ATNState
+	{
+		public override int GetStateType()
+		{
+			return Basic;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/BlockEndState.cs b/Antlr4.Runtime/Atn/BlockEndState.cs
new file mode 100644
index 000000000..9056200ed
--- /dev/null
+++ b/Antlr4.Runtime/Atn/BlockEndState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>
+	/// Terminal node of a simple
+	/// <code>(a|b|c)</code>
+	/// block.
+	/// </summary>
+	public sealed class BlockEndState : ATNState
+	{
+		public BlockStartState startState;
+
+		public override int GetStateType()
+		{
+			return BlockEnd;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/BlockStartState.cs b/Antlr4.Runtime/Atn/BlockStartState.cs
new file mode 100644
index 000000000..99332d8b1
--- /dev/null
+++ b/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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>
+	/// The start of a regular
+	/// <code>(...)</code>
+	/// block.
+	/// </summary>
+	public abstract class BlockStartState : DecisionState
+	{
+		public BlockEndState endState;
+	}
+}
diff --git a/Antlr4.Runtime/Atn/DecisionState.cs b/Antlr4.Runtime/Atn/DecisionState.cs
new file mode 100644
index 000000000..45594319c
--- /dev/null
+++ b/Antlr4.Runtime/Atn/DecisionState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public abstract class DecisionState : ATNState
+	{
+		public int decision = -1;
+
+		public bool nonGreedy;
+
+		public bool sll;
+	}
+}
diff --git a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
new file mode 100644
index 000000000..bb5daebd3
--- /dev/null
+++ b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
@@ -0,0 +1,127 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	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(CalculateHashCode(CalculateEmptyParentHashCode
+			(), CalculateEmptyReturnStateHashCode()))
+		{
+			this.fullContext = fullContext;
+		}
+
+		public bool IsFullContext()
+		{
+			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 IndexOutOfRangeException();
+		}
+
+		public override int GetReturnState(int index)
+		{
+			throw new IndexOutOfRangeException();
+		}
+
+		public override int FindReturnState(int returnState)
+		{
+			return -1;
+		}
+
+		public override int Size()
+		{
+			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()
+		{
+			return true;
+		}
+
+		public override bool HasEmpty()
+		{
+			return true;
+		}
+
+		public override bool Equals(object o)
+		{
+			return this == o;
+		}
+
+		public override string[] ToStrings<_T0>(Recognizer<_T0> recognizer, int currentState
+			)
+		{
+			return new string[] { "[]" };
+		}
+
+		public override string[] ToStrings<_T0>(Recognizer<_T0> recognizer, PredictionContext
+			 stop, int currentState)
+		{
+			return new string[] { "[]" };
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/EpsilonTransition.cs b/Antlr4.Runtime/Atn/EpsilonTransition.cs
new file mode 100644
index 000000000..dfac1c386
--- /dev/null
+++ b/Antlr4.Runtime/Atn/EpsilonTransition.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.Atn;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public sealed class EpsilonTransition : Transition
+	{
+		protected internal EpsilonTransition(ATNState target) : base(target)
+		{
+		}
+
+		public override int GetSerializationType()
+		{
+			return Epsilon;
+		}
+
+		public override bool IsEpsilon()
+		{
+			return true;
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return false;
+		}
+
+		[NotNull]
+		public override string ToString()
+		{
+			return "epsilon";
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/LL1Analyzer.cs b/Antlr4.Runtime/Atn/LL1Analyzer.cs
new file mode 100644
index 000000000..c68cbf97a
--- /dev/null
+++ b/Antlr4.Runtime/Atn/LL1Analyzer.cs
@@ -0,0 +1,232 @@
+/*
+ * [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.Misc;
+using 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 seeThruPreds==false.
+		/// </summary>
+		/// <remarks>
+		/// Special value added to the lookahead sets to indicate that we hit
+		/// a predicate during analysis if seeThruPreds==false.
+		/// </remarks>
+		public const int HitPred = Token.InvalidType;
+
+		[NotNull]
+		public readonly ATN atn;
+
+		public LL1Analyzer(ATN atn)
+		{
+			this.atn = atn;
+		}
+
+		/// <summary>
+		/// From an ATN state,
+		/// <code>s</code>
+		/// , find the set of all labels reachable from
+		/// <code>s</code>
+		/// at depth k. Only for DecisionStates.
+		/// </summary>
+		[Nullable]
+		public virtual IntervalSet[] GetDecisionLookahead(ATNState s)
+		{
+			//		System.out.println("LOOK("+s.stateNumber+")");
+			if (s == null)
+			{
+				return null;
+			}
+			IntervalSet[] look = new IntervalSet[s.GetNumberOfTransitions() + 1];
+			for (int alt = 1; alt <= s.GetNumberOfTransitions(); alt++)
+			{
+				look[alt] = new IntervalSet();
+				ICollection<ATNConfig> lookBusy = new HashSet<ATNConfig>();
+				bool seeThruPreds = false;
+				// fail to get lookahead upon pred
+				Look(s.Transition(alt - 1).target, PredictionContext.EmptyFull, look[alt], lookBusy
+					, seeThruPreds, false);
+				// Wipe out lookahead for this alternative if we found nothing
+				// or we had a predicate when we !seeThruPreds
+				if (look[alt].Size() == 0 || look[alt].Contains(HitPred))
+				{
+					look[alt] = null;
+				}
+			}
+			return look;
+		}
+
+		/// <summary>
+		/// Get lookahead, using
+		/// <code>ctx</code>
+		/// if we reach end of rule. If
+		/// <code>ctx</code>
+		/// is
+		/// <code>PredictionContext#EMPTY_LOCAL</code>
+		/// or
+		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
+		/// , don't chase FOLLOW. If
+		/// <code>ctx</code>
+		/// is
+		/// <code>PredictionContext#EMPTY_LOCAL</code>
+		/// ,
+		/// <see cref="Antlr4.Runtime.Token.Epsilon">EPSILON</see>
+		/// is in set if we can reach end of rule. If
+		/// <code>ctx</code>
+		/// is
+		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
+		/// ,
+		/// <see cref="Antlr4.Runtime.IntStream.Eof">EOF</see>
+		/// is in set
+		/// if we can reach end of rule.
+		/// </summary>
+		[NotNull]
+		public virtual IntervalSet Look(ATNState s, PredictionContext ctx)
+		{
+			Args.NotNull("ctx", ctx);
+			IntervalSet r = new IntervalSet();
+			bool seeThruPreds = true;
+			// ignore preds; get all lookahead
+			Look(s, ctx, r, new HashSet<ATNConfig>(), seeThruPreds, true);
+			return r;
+		}
+
+		/// <summary>Compute set of tokens that can come next.</summary>
+		/// <remarks>
+		/// Compute set of tokens that can come next. If the context is
+		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
+		/// ,
+		/// then we don't go anywhere when we hit the end of the rule. We have
+		/// the correct set.  If the context is
+		/// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+		/// ,
+		/// that means that we did not want any tokens following this rule--just the
+		/// tokens that could be found within this rule. Add EPSILON to the set
+		/// indicating we reached the end of the ruled out having to match a token.
+		/// </remarks>
+		protected internal virtual void Look(ATNState s, PredictionContext ctx, IntervalSet
+			 look, ICollection<ATNConfig> lookBusy, bool seeThruPreds, bool addEOF)
+		{
+			//		System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx);
+			ATNConfig c = ATNConfig.Create(s, 0, ctx);
+			if (!lookBusy.AddItem(c))
+			{
+				return;
+			}
+			if (s is RuleStopState)
+			{
+				if (PredictionContext.IsEmptyLocal(ctx))
+				{
+					look.Add(Token.Epsilon);
+					return;
+				}
+				else
+				{
+					if (ctx.IsEmpty() && addEOF)
+					{
+						look.Add(Token.Eof);
+						return;
+					}
+				}
+				for (int i = 0; i < ctx.Size(); i++)
+				{
+					if (ctx.GetReturnState(i) != PredictionContext.EmptyFullStateKey)
+					{
+						ATNState returnState = atn.states[ctx.GetReturnState(i)];
+						//			System.out.println("popping back to "+retState);
+						for (int j = 0; j < ctx.Size(); j++)
+						{
+							Look(returnState, ctx.GetParent(j), look, lookBusy, seeThruPreds, addEOF);
+						}
+						return;
+					}
+				}
+			}
+			int n = s.GetNumberOfTransitions();
+			for (int i_1 = 0; i_1 < n; i_1++)
+			{
+				Transition t = s.Transition(i_1);
+				if (t.GetType() == typeof(RuleTransition))
+				{
+					PredictionContext newContext = ctx.GetChild(((RuleTransition)t).followState.stateNumber
+						);
+					Look(t.target, newContext, look, lookBusy, seeThruPreds, addEOF);
+				}
+				else
+				{
+					if (t is AbstractPredicateTransition)
+					{
+						if (seeThruPreds)
+						{
+							Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
+						}
+						else
+						{
+							look.Add(HitPred);
+						}
+					}
+					else
+					{
+						if (t.IsEpsilon())
+						{
+							Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
+						}
+						else
+						{
+							if (t.GetType() == typeof(WildcardTransition))
+							{
+								look.AddAll(IntervalSet.Of(Token.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(Token.MinUserTokenType, atn.maxTokenType));
+									}
+									look.AddAll(set);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/LexerATNSimulator.cs b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
new file mode 100644
index 000000000..8962464d7
--- /dev/null
+++ b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
@@ -0,0 +1,742 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>"dup" of ParserInterpreter</summary>
+	public class LexerATNSimulator : ATNSimulator
+	{
+		public const bool debug = false;
+
+		public const bool dfa_debug = false;
+
+		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.IntStream.Mark()">Antlr4.Runtime.IntStream.Mark()</see>
+		/// 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.
+		/// </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>
+		protected internal 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(CharStream 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;
+		}
+
+		// only called from test code from outside
+		protected internal virtual int MatchATN(CharStream input)
+		{
+			ATNState startState = atn.modeToStartState[mode];
+			int old_mode = 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(CharStream input, DFAState ds0)
+		{
+			//System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
+			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.
+				ATNConfigSet closure = s.configs;
+				DFAState target = null;
+				target = s.GetTarget(t);
+				if (target == Error)
+				{
+					break;
+				}
+				if (debug && target != null)
+				{
+					System.Console.Out.WriteLine("reuse state " + s.stateNumber + " edge to " + target
+						.stateNumber);
+				}
+				if (target == null)
+				{
+					ATNConfigSet reach = new OrderedATNConfigSet();
+					// if we don't find an existing DFA state
+					// Fill reach starting from closure, following t transitions
+					GetReachableConfigSet(input, closure, reach, t);
+					if (reach.IsEmpty())
+					{
+						// we got nowhere on t from s
+						// we reached state associated with closure for sure, so
+						// make sure it's defined. worst case, we define s0 from
+						// start state configs.
+						DFAState from = s != null ? s : AddDFAState(closure);
+						// we got nowhere on t, don't throw out this knowledge; it'd
+						// cause a failover from DFA later.
+						AddDFAEdge(from, t, Error);
+						break;
+					}
+					// stop when we can't match any more char
+					// Add an edge from s to target DFA found/created for reach
+					target = AddDFAEdge(s, t, reach);
+				}
+				if (target.isAcceptState)
+				{
+					CaptureSimState(prevAccept, input, target);
+					if (t == IntStream.Eof)
+					{
+						break;
+					}
+				}
+				if (t != IntStream.Eof)
+				{
+					Consume(input);
+					t = input.La(1);
+				}
+				s = target;
+			}
+			// flip; current DFA target becomes new src/from state
+			return FailOrAccept(prevAccept, input, s.configs, t);
+		}
+
+		protected internal virtual int FailOrAccept(LexerATNSimulator.SimState prevAccept
+			, CharStream input, ATNConfigSet reach, int t)
+		{
+			if (prevAccept.dfaState != null)
+			{
+				int ruleIndex = prevAccept.dfaState.lexerRuleIndex;
+				int actionIndex = prevAccept.dfaState.lexerActionIndex;
+				Accept(input, ruleIndex, actionIndex, prevAccept.index, prevAccept.line, prevAccept
+					.charPos);
+				return prevAccept.dfaState.prediction;
+			}
+			else
+			{
+				// if no accept and EOF is first char, return EOF
+				if (t == IntStream.Eof && input.Index() == startIndex)
+				{
+					return Token.Eof;
+				}
+				throw new LexerNoViableAltException(recog, input, startIndex, reach);
+			}
+		}
+
+		/// <summary>
+		/// Given a starting configuration set, figure out all ATN configurations
+		/// we can reach upon input
+		/// <code>t</code>
+		/// . Parameter
+		/// <code>reach</code>
+		/// is a return
+		/// parameter.
+		/// </summary>
+		protected internal virtual 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.InvalidAltNumber;
+			foreach (ATNConfig c in closure)
+			{
+				if (c.GetAlt() == skipAlt)
+				{
+					continue;
+				}
+				int n = c.GetState().GetNumberOfOptimizedTransitions();
+				for (int ti = 0; ti < n; ti++)
+				{
+					// for each optimized transition
+					Transition trans = c.GetState().GetOptimizedTransition(ti);
+					ATNState target = GetReachableTarget(trans, t);
+					if (target != null)
+					{
+						if (Closure(input, c.Transform(target), reach, true))
+						{
+							// any remaining configs for this alt have a lower priority than
+							// the one that just reached an accept state.
+							skipAlt = c.GetAlt();
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		protected internal virtual void Accept(CharStream input, int ruleIndex, int actionIndex
+			, int index, int line, int charPos)
+		{
+			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);
+			}
+		}
+
+		[Nullable]
+		public virtual ATNState GetReachableTarget(Transition trans, int t)
+		{
+			if (trans.Matches(t, Lexer.MinCharValue, Lexer.MaxCharValue))
+			{
+				return trans.target;
+			}
+			return null;
+		}
+
+		[NotNull]
+		protected internal virtual ATNConfigSet ComputeStartState(CharStream input, ATNState
+			 p)
+		{
+			PredictionContext initialContext = PredictionContext.EmptyFull;
+			ATNConfigSet configs = new OrderedATNConfigSet();
+			for (int i = 0; i < p.GetNumberOfTransitions(); i++)
+			{
+				ATNState target = p.Transition(i).target;
+				ATNConfig c = ATNConfig.Create(target, i + 1, initialContext);
+				Closure(input, c, configs, 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
+		/// <code>config</code>
+		/// , all other (potentially reachable) states for
+		/// this rule would have a lower priority.
+		/// </remarks>
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// if an accept state is reached, otherwise
+		/// <code>false</code>
+		/// .
+		/// </returns>
+		protected internal virtual bool Closure(CharStream input, ATNConfig config, ATNConfigSet
+			 configs, bool speculative)
+		{
+			if (config.GetState() is RuleStopState)
+			{
+				PredictionContext context = config.GetContext();
+				if (context.IsEmpty())
+				{
+					configs.AddItem(config);
+					return true;
+				}
+				else
+				{
+					if (context.HasEmpty())
+					{
+						configs.AddItem(config.Transform(config.GetState(), PredictionContext.EmptyFull));
+						return 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 = ATNConfig.Create(returnState, config.GetAlt(), newContext);
+					if (Closure(input, c, configs, speculative))
+					{
+						return true;
+					}
+				}
+				return false;
+			}
+			// optimization
+			if (!config.GetState().OnlyHasEpsilonTransitions())
+			{
+				configs.AddItem(config);
+			}
+			ATNState p = config.GetState();
+			for (int i_1 = 0; i_1 < p.GetNumberOfOptimizedTransitions(); i_1++)
+			{
+				Transition t = p.GetOptimizedTransition(i_1);
+				ATNConfig c = GetEpsilonTarget(input, config, t, configs, speculative);
+				if (c != null)
+				{
+					if (Closure(input, c, configs, speculative))
+					{
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+		// side-effect: can alter configs.hasSemanticContext
+		[Nullable]
+		public virtual ATNConfig GetEpsilonTarget(CharStream input, ATNConfig config, Transition
+			 t, ATNConfigSet configs, bool speculative)
+		{
+			ATNConfig c;
+			switch (t.GetSerializationType())
+			{
+				case Transition.Rule:
+				{
+					RuleTransition ruleTransition = (RuleTransition)t;
+					if (optimize_tail_calls && ruleTransition.optimizedTailCall && !config.GetContext
+						().HasEmpty())
+					{
+						c = config.Transform(t.target);
+					}
+					else
+					{
+						PredictionContext newContext = config.GetContext().GetChild(ruleTransition.followState
+							.stateNumber);
+						c = config.Transform(t.target, newContext);
+					}
+					break;
+				}
+
+				case Transition.Precedence:
+				{
+					throw new NotSupportedException("Precedence predicates are not supported in lexers."
+						);
+				}
+
+				case Transition.Predicate:
+				{
+					PredicateTransition pt = (PredicateTransition)t;
+					configs.MarkExplicitSemanticContext();
+					if (EvaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative))
+					{
+						c = config.Transform(t.target);
+					}
+					else
+					{
+						c = null;
+					}
+					break;
+				}
+
+				case Transition.Action:
+				{
+					// ignore actions; just exec one per rule upon accept
+					c = config.Transform(t.target, ((ActionTransition)t).actionIndex);
+					break;
+				}
+
+				case Transition.Epsilon:
+				{
+					c = config.Transform(t.target);
+					break;
+				}
+
+				default:
+				{
+					c = null;
+					break;
+					break;
+				}
+			}
+			return c;
+		}
+
+		/// <summary>Evaluate a predicate specified in the lexer.</summary>
+		/// <remarks>
+		/// Evaluate a predicate specified in the lexer.
+		/// <p/>
+		/// If
+		/// <code>speculative</code>
+		/// is
+		/// <code>true</code>
+		/// , this method was called before
+		/// <see cref="Consume(Antlr4.Runtime.CharStream)">Consume(Antlr4.Runtime.CharStream)
+		/// 	</see>
+		/// for the matched character. This method should call
+		/// <see cref="Consume(Antlr4.Runtime.CharStream)">Consume(Antlr4.Runtime.CharStream)
+		/// 	</see>
+		/// before evaluating the predicate to ensure position
+		/// sensitive values, including
+		/// <see cref="Antlr4.Runtime.Lexer.GetText()">Antlr4.Runtime.Lexer.GetText()</see>
+		/// ,
+		/// <see cref="Antlr4.Runtime.Lexer.GetLine()">Antlr4.Runtime.Lexer.GetLine()</see>
+		/// ,
+		/// and
+		/// <see cref="Antlr4.Runtime.Lexer.GetCharPositionInLine()">Antlr4.Runtime.Lexer.GetCharPositionInLine()
+		/// 	</see>
+		/// , properly reflect the current
+		/// lexer state. This method should restore
+		/// <code>input</code>
+		/// and the simulator
+		/// to the original state before returning (i.e. undo the actions made by the
+		/// call to
+		/// <see cref="Consume(Antlr4.Runtime.CharStream)">Consume(Antlr4.Runtime.CharStream)
+		/// 	</see>
+		/// .
+		/// </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">
+		/// 
+		/// <code>true</code>
+		/// if the current index in
+		/// <code>input</code>
+		/// is
+		/// one character before the predicate's location.
+		/// </param>
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// if the specified predicate evaluates to
+		/// <code>true</code>
+		/// .
+		/// </returns>
+		protected internal virtual bool EvaluatePredicate(CharStream 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
+			, CharStream input, DFAState dfaState)
+		{
+			settings.index = input.Index();
+			settings.line = line;
+			settings.charPos = charPositionInLine;
+			settings.dfaState = dfaState;
+		}
+
+		[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>
+		[NotNull]
+		protected internal virtual DFAState AddDFAState(ATNConfigSet configs)
+		{
+			System.Diagnostics.Debug.Assert(!configs.HasSemanticContext());
+			DFAState proposed = new DFAState(configs, 0, MaxDfaEdge);
+			DFAState existing = atn.modeToDFA[mode].states.Get(proposed);
+			if (existing != null)
+			{
+				return existing;
+			}
+			configs.OptimizeConfigs(this);
+			DFAState newState = new DFAState(configs.Clone(true), 0, MaxDfaEdge);
+			ATNConfig firstConfigWithRuleStopState = null;
+			foreach (ATNConfig c in configs)
+			{
+				if (c.GetState() is RuleStopState)
+				{
+					firstConfigWithRuleStopState = c;
+					break;
+				}
+			}
+			if (firstConfigWithRuleStopState != null)
+			{
+				newState.isAcceptState = true;
+				newState.lexerRuleIndex = firstConfigWithRuleStopState.GetState().ruleIndex;
+				newState.lexerActionIndex = firstConfigWithRuleStopState.GetActionIndex();
+				newState.prediction = atn.ruleToTokenType[newState.lexerRuleIndex];
+			}
+			return atn.modeToDFA[mode].AddState(newState);
+		}
+
+		[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>
+		[NotNull]
+		public virtual string GetText(CharStream input)
+		{
+			// index is first lookahead char, don't include.
+			return input.GetText(Interval.Of(startIndex, input.Index() - 1));
+		}
+
+		public virtual int GetLine()
+		{
+			return line;
+		}
+
+		public virtual void SetLine(int line)
+		{
+			this.line = line;
+		}
+
+		public virtual int GetCharPositionInLine()
+		{
+			return charPositionInLine;
+		}
+
+		public virtual void SetCharPositionInLine(int charPositionInLine)
+		{
+			this.charPositionInLine = charPositionInLine;
+		}
+
+		public virtual void Consume(CharStream input)
+		{
+			int curChar = input.La(1);
+			if (curChar == '\n')
+			{
+				line++;
+				charPositionInLine = 0;
+			}
+			else
+			{
+				charPositionInLine++;
+			}
+			input.Consume();
+		}
+
+		[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/Antlr4.Runtime/Atn/LoopEndState.cs b/Antlr4.Runtime/Atn/LoopEndState.cs
new file mode 100644
index 000000000..b701f7b91
--- /dev/null
+++ b/Antlr4.Runtime/Atn/LoopEndState.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 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 int GetStateType()
+		{
+			return LoopEnd;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/NotSetTransition.cs b/Antlr4.Runtime/Atn/NotSetTransition.cs
new file mode 100644
index 000000000..12c9bcda8
--- /dev/null
+++ b/Antlr4.Runtime/Atn/NotSetTransition.cs
@@ -0,0 +1,58 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public sealed class NotSetTransition : SetTransition
+	{
+		public NotSetTransition(ATNState target, IntervalSet set) : base(target, set)
+		{
+		}
+
+		public override int GetSerializationType()
+		{
+			return 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/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs b/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
new file mode 100644
index 000000000..00ffbb737
--- /dev/null
+++ b/Antlr4.Runtime/Atn/OrderedATNConfigSet.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.
+ */
+using Antlr4.Runtime.Atn;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <author>Sam Harwell</author>
+	public class OrderedATNConfigSet : ATNConfigSet
+	{
+		public OrderedATNConfigSet()
+		{
+		}
+
+		protected internal 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())
+			{
+				Sharpen.Collections.AddAll(copy, 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/Antlr4.Runtime/Atn/ParserATNPathFinder.cs b/Antlr4.Runtime/Atn/ParserATNPathFinder.cs
new file mode 100644
index 000000000..79200b6d7
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ParserATNPathFinder.cs
@@ -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.
+ */
+using Antlr4.Runtime.Atn;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public class ParserATNPathFinder
+	{
+		//	public ParserATNPathFinder(@Nullable Parser<Token> parser, @NotNull ATN atn) {
+		//		super(parser, atn);
+		//	}
+		//
+		//	/** Given an input sequence, as a subset of the input stream, trace the path through the
+		//	 *  ATN starting at s. The path returned includes s and the final target of the last input
+		//	 *  symbol. If there are multiple paths through the ATN to the final state, it uses the first
+		//	 *  method finds. This is used to figure out how input sequence is matched in more than one
+		//	 *  way between the alternatives of a decision. It's only that decision we are concerned with
+		//	 *  and so if there are ambiguous decisions further along, we will ignore them for the
+		//	 *  purposes of computing the path to the final state. To figure out multiple paths for
+		//	 *  decision, use this method  on the left edge of the alternatives of the decision in question.
+		//	 *
+		//	 *  TODO: I haven't figured out what to do with nongreedy decisions yet
+		//	 *  TODO: preds. unless i create rule specific ctxs, i can't eval preds. also must eval args!
+		//	 */
+		//	public TraceTree trace(@NotNull ATNState s, @Nullable RuleContext<Token> ctx,
+		//								TokenStream<? extends Token> input, int start, int stop)
+		//	{
+		//		System.out.println("REACHES "+s.stateNumber+" start state");
+		//		List<TraceTree> leaves = new ArrayList<TraceTree>();
+		//		@SuppressWarnings("unchecked") // safe
+		//		HashSet<ATNState>[] busy = (HashSet<ATNState>[])new HashSet<?>[stop-start+1];
+		//		for (int i = 0; i < busy.length; i++) {
+		//			busy[i] = new HashSet<ATNState>();
+		//		}
+		//		TraceTree path = _trace(s, ctx, ctx, input, start, start, stop, leaves, busy);
+		//		if ( path!=null ) path.leaves = leaves;
+		//		return path;
+		//	}
+		//
+		//	/** Returns true if we found path */
+		//	public TraceTree _trace(@NotNull ATNState s, RuleContext<Token> initialContext, RuleContext<Token> ctx,
+		//							TokenStream<? extends Token> input, int start, int i, int stop,
+		//							List<TraceTree> leaves, @NotNull Set<ATNState>[] busy)
+		//	{
+		//		TraceTree root = new TraceTree(s);
+		//		if ( i>stop ) {
+		//			leaves.add(root); // track final states
+		//			System.out.println("leaves=" + leaves);
+		//			return root;
+		//		}
+		//
+		//		if ( !busy[i-start].add(s) ) {
+		//			System.out.println("already visited "+s.stateNumber+" at input "+i+"="+input.get(i).getText());
+		//			return null;
+		//		}
+		//		busy[i-start].add(s);
+		//
+		//		System.out.println("TRACE "+s.stateNumber+" at input "+input.get(i).getText());
+		//
+		//		if ( s instanceof RuleStopState) {
+		//			// We hit rule end. If we have context info, use it
+		//			if ( ctx!=null && !ctx.isEmpty() ) {
+		//				System.out.println("stop state "+s.stateNumber+", ctx="+ctx);
+		//				ATNState invokingState = atn.states.get(ctx.invokingState);
+		//				RuleTransition rt = (RuleTransition)invokingState.transition(0);
+		//				ATNState retState = rt.followState;
+		//				return _trace(retState, initialContext, ctx.parent, input, start, i, stop, leaves, busy);
+		//			}
+		//			else {
+		//				// else if we have no context info, just chase follow links (if greedy)
+		//				System.out.println("FALLING off rule "+getRuleName(s.ruleIndex));
+		//			}
+		//		}
+		//
+		//		int n = s.getNumberOfTransitions();
+		//		boolean aGoodPath = false;
+		//		TraceTree found;
+		//		for (int j=0; j<n; j++) {
+		//			Transition t = s.transition(j);
+		//			if ( t.getClass() == RuleTransition.class ) {
+		//				RuleContext<Token> newContext = RuleContext.getChildContext(ctx, s.stateNumber);
+		//				found = _trace(t.target, initialContext, newContext, input, start, i, stop, leaves, busy);
+		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+		//				continue;
+		//			}
+		//			if ( t instanceof PredicateTransition ) {
+		//				found = predTransition(initialContext, ctx, input, start, i, stop, leaves, busy, root, t);
+		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+		//				continue;
+		//			}
+		//			if ( t.isEpsilon() ) {
+		//				found = _trace(t.target, initialContext, ctx, input, start, i, stop, leaves, busy);
+		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+		//				continue;
+		//			}
+		//			if ( t.getClass() == WildcardTransition.class ) {
+		//				System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
+		//				found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
+		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+		//				continue;
+		//			}
+		//			IntervalSet set = t.label();
+		//			if ( set!=null ) {
+		//				if ( t instanceof NotSetTransition ) {
+		//					if ( !set.contains(input.get(i).getType()) ) {
+		//						System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
+		//						found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
+		//						if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+		//					}
+		//				}
+		//				else {
+		//					if ( set.contains(input.get(i).getType()) ) {
+		//						System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
+		//						found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
+		//						if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+		//					}
+		//				}
+		//			}
+		//		}
+		//		if ( aGoodPath ) return root; // found at least one transition leading to success
+		//		return null;
+		//	}
+		//
+		//	public TraceTree predTransition(RuleContext<Token> initialContext, RuleContext<Token> ctx, TokenStream<? extends Token> input, int start,
+		//									int i, int stop, List<TraceTree> leaves, Set<ATNState>[] busy,
+		//									TraceTree root, Transition t)
+		//	{
+		//		SemanticContext.Predicate pred = ((PredicateTransition) t).getPredicate();
+		//		boolean pass;
+		//		if ( pred.isCtxDependent ) {
+		//			if ( ctx instanceof ParserRuleContext && ctx==initialContext ) {
+		//				System.out.println("eval pred "+pred+"="+pred.eval(parser, ctx));
+		//				pass = pred.eval(parser, ctx);
+		//			}
+		//			else {
+		//				pass = true; // see thru ctx dependent when out of context
+		//			}
+		//		}
+		//		else {
+		//			System.out.println("eval pred "+pred+"="+pred.eval(parser, initialContext));
+		//			pass = pred.eval(parser, ctx);
+		//		}
+		//		if ( pass ) {
+		//			return _trace(t.target, initialContext, ctx, input, start, i, stop, leaves, busy);
+		//		}
+		//		return null;
+		//	}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/ParserATNSimulator.cs b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
new file mode 100644
index 000000000..b481901e4
--- /dev/null
+++ b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
@@ -0,0 +1,2182 @@
+/*
+ * [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.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>The embodiment of the adaptive LL(*) parsing strategy.</summary>
+	/// <remarks>
+	/// The embodiment of the adaptive LL(*) 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
+	/// 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 entry rule.  For
+	/// example, if prediction occurs without invoking another rule's
+	/// ATN, there are no context stacks in the configurations. When this
+	/// 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(*)).
+	/// So, we simply retry the ATN simulation again, this time
+	/// using full outer context and filling a dummy DFA (to avoid
+	/// polluting the context insensitive DFA). Configuration context
+	/// stacks will be the full invocation stack 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.) We create a special DFA accept state
+	/// that maps rule context to a predicted alternative. That is the
+	/// only modification needed to handle full LL(*) prediction. In
+	/// general, full context prediction will use more lookahead than
+	/// necessary, but it pays to share the same DFA. For a schedule
+	/// proof that full context prediction uses that most the same amount
+	/// of lookahead as a context insensitive prediction, see the comment
+	/// on method retryWithContext().
+	/// So, the strategy is complex because we bounce back and forth from
+	/// the ATN to the DFA, simultaneously performing predictions and
+	/// extending the DFA according to previously unseen input
+	/// sequences. The retry with full context is a recursive call to the
+	/// same function naturally because it does the same thing, just with
+	/// a different initial context. The problem is, that we need to pass
+	/// in a "full context mode" parameter so that it knows to report
+	/// conflicts differently. It also knows not to do a retry, to avoid
+	/// infinite recursion, if it is already using full context.
+	/// Retry a simulation using full outer context.
+	/// One of the key assumptions here is that using full context
+	/// can use at most the same amount of input as a simulation
+	/// that is not useful context (i.e., it uses all possible contexts
+	/// that could invoke our entry rule. I believe that this is true
+	/// and the proof might go like this.
+	/// THEOREM:  The amount of input consumed during a full context
+	/// simulation is at most the amount of input consumed during a
+	/// non full context simulation.
+	/// PROOF: Let D be the DFA state at which non-context simulation
+	/// terminated. That means that D does not have a configuration for
+	/// which we can legally pursue more input. (It is legal to work only
+	/// on configurations for which there is no conflict with another
+	/// configuration.) Now we restrict ourselves to following ATN edges
+	/// associated with a single context. Choose any DFA state D' along
+	/// the path (same input) to D. That state has either the same number
+	/// of configurations or fewer. (If the number of configurations is
+	/// the same, then we have degenerated to the non-context case.) Now
+	/// imagine that we restrict to following edges associated with
+	/// another single context and that we reach DFA state D'' for the
+	/// same amount of input as D'. The non-context simulation merges D'
+	/// and D''. The union of the configuration sets either has the same
+	/// number of configurations as both D' and D'' or it has more. If it
+	/// has the same number, we are no worse off and the merge does not
+	/// force us to look for more input than we would otherwise have to
+	/// do. If the union has more configurations, it can introduce
+	/// conflicts but not new alternatives--we cannot conjure up alternatives
+	/// by computing closure on the DFA state.  Here are the cases for
+	/// D' union D'':
+	/// 1. No increase in configurations, D' = D''
+	/// 2. Add configuration that introduces a new alternative number.
+	/// This cannot happen because no new alternatives are introduced
+	/// while computing closure, even during start state computation.
+	/// 3. D'' adds a configuration that does not conflict with any
+	/// configuration in D'.  Simulating without context would then have
+	/// forced us to use more lookahead than D' (full context) alone.
+	/// 3. D'' adds a configuration that introduces a conflict with a
+	/// configuration in D'. There are 2 cases:
+	/// a. The conflict does not cause termination (D' union D''
+	/// is added to the work list). Again no context simulation requires
+	/// more input.
+	/// b. The conflict does cause termination, but this cannot happen.
+	/// By definition, we know that with ALL contexts merged we
+	/// don't terminate until D and D' uses less input than D. Therefore
+	/// no context simulation requires more input than full context
+	/// simulation.
+	/// We have covered all the cases and there is never a situation where
+	/// a single, full context simulation requires more input than a
+	/// no context simulation.
+	/// I spent a bunch of time thinking about this problem after finding
+	/// a case where context-sensitive ATN simulation looks beyond what they
+	/// no context simulation uses. the no context simulation for if then else
+	/// stops at the else whereas full context scans through to the end of the
+	/// statement to decide that the "else statement" clause is ambiguous. And
+	/// sometimes it is not ambiguous! Ok, I made an untrue assumption in my
+	/// proof which I won't bother going to. the important thing is what I'm
+	/// going to do about it. I thought I had a simple answer, but nope. It
+	/// turns out that the if then else case is perfect example of something
+	/// that has the following characteristics:
+	/// no context conflicts at k=1
+	/// full context at k=(1 + length of statement) can be both ambiguous and not
+	/// ambiguous depending on the input, though I think from different contexts.
+	/// But, the good news is that the k=1 case is a special case in that
+	/// SLL(1) and LL(1) have exactly the same power so we can conclude that
+	/// conflicts at k=1 are true ambiguities and we do not need to pursue
+	/// context-sensitive parsing. That covers a huge number of cases
+	/// including the if then else clause and the predicated precedence
+	/// parsing mechanism. whew! because that could be extremely expensive if
+	/// we had to do context.
+	/// Further, there is no point in doing full context if none of the
+	/// configurations dip into the outer context. This nicely handles cases
+	/// such 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.
+	/// So, we now cover what I hope is the vast majority of the cases (in
+	/// particular the very important precedence parsing case). Anything that
+	/// needs k&gt;1 and dips into the outer context requires a full context
+	/// retry. In this case, I'm going to start out with a brain-dead solution
+	/// which is to mark the DFA state as context-sensitive when I get a
+	/// conflict. Any further DFA simulation that reaches that state will
+	/// launch an ATN simulation to get the prediction, without updating the
+	/// DFA or storing any context information. Later, I can make this more
+	/// efficient, but at least in this case I can guarantee that it will
+	/// always do the right thing. We are not making any assumptions about
+	/// lookahead depth.
+	/// Ok, writing this up so I can put in a comment.
+	/// Upon conflict in the no context simulation:
+	/// if k=1, report ambiguity and resolve to the minimum conflicting alternative
+	/// if k=1 and predicates, no report and include the predicate to
+	/// predicted alternative map in the DFA state
+	/// if k=* and we did not dip into the outer context, report ambiguity
+	/// and resolve to minimum conflicting alternative
+	/// if k&gt;1 and we dip into outer context, retry with full context
+	/// if conflict, report ambiguity and resolve to minimum conflicting
+	/// alternative, mark DFA as context-sensitive
+	/// If no conflict, report ctx sensitivity and mark DFA as context-sensitive
+	/// Technically, if full context k is less than no context k, we can
+	/// reuse the conflicting DFA state so we don't have to create special
+	/// DFA paths branching from context, but we can leave that for
+	/// optimization later if necessary.
+	/// if non-greedy, no report and resolve to the exit alternative
+	/// 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>
+	public class ParserATNSimulator : ATNSimulator
+	{
+		public const bool debug = false;
+
+		public const bool dfa_debug = false;
+
+		public const bool retry_debug = false;
+
+		private PredictionMode predictionMode = PredictionMode.Ll;
+
+		public bool force_global_context = false;
+
+		public bool always_try_local_context = true;
+
+		public bool optimize_unique_closure = true;
+
+		public bool optimize_ll1 = true;
+
+		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;
+
+		public static bool optimize_closure_busy = true;
+
+		[Nullable]
+		protected internal readonly Parser parser;
+
+		/// <summary>
+		/// When
+		/// <code>true</code>
+		/// , ambiguous alternatives are reported when they are
+		/// encountered within
+		/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.TokenStream, int, SimulatorState)
+		/// 	">ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.TokenStream, int, SimulatorState)
+		/// 	</see>
+		/// . When
+		/// <code>false</code>
+		/// , these messages
+		/// are suppressed. The default is
+		/// <code>false</code>
+		/// .
+		/// <p>
+		/// When messages about ambiguous alternatives are not required, setting this
+		/// to
+		/// <code>false</code>
+		/// 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;
+
+		/// <summary>Testing only!</summary>
+		public ParserATNSimulator(ATN atn) : this(null, atn)
+		{
+		}
+
+		public ParserATNSimulator(Parser parser, ATN atn) : base(atn)
+		{
+			this.parser = parser;
+		}
+
+		[NotNull]
+		public PredictionMode GetPredictionMode()
+		{
+			return predictionMode;
+		}
+
+		public void SetPredictionMode(PredictionMode predictionMode)
+		{
+			this.predictionMode = predictionMode;
+		}
+
+		public override void Reset()
+		{
+		}
+
+		public virtual int AdaptivePredict(TokenStream input, int decision, ParserRuleContext
+			 outerContext)
+		{
+			return AdaptivePredict(input, decision, outerContext, false);
+		}
+
+		public virtual int AdaptivePredict(TokenStream input, int decision, ParserRuleContext
+			 outerContext, bool useContext)
+		{
+			DFA dfa = atn.decisionToDFA[decision];
+			System.Diagnostics.Debug.Assert(dfa != null);
+			if (optimize_ll1 && !dfa.IsEmpty())
+			{
+				int ll_1 = input.La(1);
+				if (ll_1 >= 0 && ll_1 <= short.MaxValue)
+				{
+					int key = (decision << 16) + ll_1;
+					int alt = atn.LL1Table.Get(key);
+					if (alt != null)
+					{
+						return alt;
+					}
+				}
+			}
+			if (force_global_context)
+			{
+				useContext = true;
+			}
+			else
+			{
+				if (!always_try_local_context)
+				{
+					useContext |= dfa != null && dfa.IsContextSensitive();
+				}
+			}
+			userWantsCtxSensitive = useContext || (predictionMode != PredictionMode.Sll && outerContext
+				 != null && !atn.decisionToState[decision].sll);
+			if (outerContext == null)
+			{
+				outerContext = ParserRuleContext.EmptyContext();
+			}
+			SimulatorState state = null;
+			if (!dfa.IsEmpty())
+			{
+				state = GetStartState(dfa, input, outerContext, useContext);
+			}
+			if (state == null)
+			{
+				return PredictATN(dfa, input, outerContext, useContext);
+			}
+			else
+			{
+				//dump(dfa);
+				// start with the DFA
+				int m = input.Mark();
+				int index = input.Index();
+				try
+				{
+					int alt = ExecDFA(dfa, input, index, state);
+					return alt;
+				}
+				finally
+				{
+					input.Seek(index);
+					input.Release(m);
+				}
+			}
+		}
+
+		public virtual SimulatorState GetStartState(DFA dfa, TokenStream input, ParserRuleContext
+			 outerContext, bool useContext)
+		{
+			if (!useContext)
+			{
+				if (dfa.s0.Get() == null)
+				{
+					return null;
+				}
+				return new SimulatorState(outerContext, dfa.s0.Get(), false, outerContext);
+			}
+			ParserRuleContext remainingContext = outerContext;
+			System.Diagnostics.Debug.Assert(outerContext != null);
+			DFAState 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.GetParent());
+				}
+			}
+			if (s0 == null)
+			{
+				return null;
+			}
+			return new SimulatorState(outerContext, s0, useContext, remainingContext);
+		}
+
+		public virtual int PredictATN(DFA dfa, TokenStream input, ParserRuleContext outerContext
+			, bool useContext)
+		{
+			if (outerContext == null)
+			{
+				outerContext = ParserRuleContext.EmptyContext();
+			}
+			int alt = 0;
+			int m = input.Mark();
+			int index = input.Index();
+			try
+			{
+				SimulatorState state = ComputeStartState(dfa, outerContext, useContext);
+				if (state.s0.isAcceptState)
+				{
+					return ExecDFA(dfa, input, index, state);
+				}
+				else
+				{
+					alt = ExecATN(dfa, input, index, state);
+				}
+			}
+			catch (NoViableAltException nvae)
+			{
+				throw;
+			}
+			finally
+			{
+				input.Seek(index);
+				input.Release(m);
+			}
+			return alt;
+		}
+
+		public virtual int ExecDFA(DFA dfa, TokenStream input, int startIndex, SimulatorState
+			 state)
+		{
+			ParserRuleContext outerContext = state.outerContext;
+			DFAState acceptState = null;
+			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);
+						}
+						remainingOuterContext = ((ParserRuleContext)remainingOuterContext.GetParent());
+						s = next;
+					}
+				}
+				if (s.isAcceptState)
+				{
+					if (s.predicates != null)
+					{
+					}
+					acceptState = s;
+					// 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(!s.isAcceptState);
+				// if no edge, pop over to ATN interpreter, update DFA and return
+				DFAState target = s.GetTarget(t);
+				if (target == null)
+				{
+					if (dfa_debug && t >= 0)
+					{
+						System.Console.Out.WriteLine("no edge for " + parser.GetTokenNames()[t]);
+					}
+					int alt;
+					SimulatorState initialState = new SimulatorState(outerContext, s, state.useContext
+						, remainingOuterContext);
+					alt = ExecATN(dfa, input, startIndex, initialState);
+					// this adds edge even if next state is accept for
+					// same alt; e.g., s0-A->:s1=>2-B->:s2=>2
+					// TODO: This next stuff kills edge, but extra states remain. :(
+					if (s.isAcceptState && alt != -1)
+					{
+						DFAState d = s.GetTarget(input.La(1));
+						if (d.isAcceptState && d.prediction == s.prediction)
+						{
+							// we can carve it out.
+							s.SetTarget(input.La(1), Error);
+						}
+					}
+					// IGNORE really not error
+					//dump(dfa);
+					// action already executed
+					return alt;
+				}
+				else
+				{
+					// we've updated DFA, exec'd action, and have our deepest answer
+					if (target == Error)
+					{
+						throw NoViableAlt(input, outerContext, s.configs, startIndex);
+					}
+				}
+				s = target;
+				if (!s.isAcceptState && t != IntStream.Eof)
+				{
+					input.Consume();
+					t = input.La(1);
+				}
+			}
+			//		if ( acceptState==null ) {
+			//			if ( debug ) System.out.println("!!! no viable alt in dfa");
+			//			return -1;
+			//		}
+			if (acceptState.configs.GetConflictingAlts() != null)
+			{
+				if (dfa.atnStartState is DecisionState)
+				{
+					if (!userWantsCtxSensitive || !acceptState.configs.GetDipsIntoOuterContext() || (
+						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
+						if (acceptState.predicates != null)
+						{
+							int conflictIndex = input.Index();
+							if (conflictIndex != startIndex)
+							{
+								input.Seek(startIndex);
+							}
+							BitSet predictions = EvalSemanticContext(s.predicates, outerContext, true);
+							if (predictions.Cardinality() == 1)
+							{
+								return predictions.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 fullContextState = ComputeStartState(dfa, outerContext, true);
+							ReportAttemptingFullContext(dfa, fullContextState, 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
+			if (s.predicates != null)
+			{
+				int stopIndex = input.Index();
+				if (startIndex != stopIndex)
+				{
+					input.Seek(startIndex);
+				}
+				BitSet alts = EvalSemanticContext(s.predicates, outerContext, reportAmbiguities &&
+					 predictionMode == 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, alts, s.configs);
+						return alts.NextSetBit(0);
+						break;
+					}
+				}
+			}
+			return acceptState.prediction;
+		}
+
+		/// <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>
+		public virtual int ExecATN(DFA dfa, TokenStream input, int startIndex, SimulatorState
+			 initialState)
+		{
+			ParserRuleContext outerContext = initialState.outerContext;
+			bool useContext = initialState.useContext;
+			int t = input.La(1);
+			DecisionState decState = atn.GetDecisionState(dfa.decision);
+			SimulatorState previous = initialState;
+			PredictionContextCache contextCache = new PredictionContextCache();
+			while (true)
+			{
+				// while more work
+				SimulatorState nextState = ComputeReachSet(dfa, previous, t, contextCache);
+				if (nextState == null)
+				{
+					return HandleNoViableAlt(input, startIndex, previous);
+				}
+				DFAState D = nextState.s0;
+				ATNConfigSet reach = D.configs;
+				// predicted alt => accept state
+				System.Diagnostics.Debug.Assert(D.isAcceptState || GetUniqueAlt(reach) == ATN.InvalidAltNumber
+					);
+				// conflicted => accept state
+				System.Diagnostics.Debug.Assert(D.isAcceptState || D.configs.GetConflictingAlts()
+					 == null);
+				if (D.isAcceptState)
+				{
+					int predictedAlt = reach.GetConflictingAlts() == null ? GetUniqueAlt(reach) : ATN
+						.InvalidAltNumber;
+					if (predictedAlt != ATN.InvalidAltNumber)
+					{
+						if (optimize_ll1 && input.Index() == startIndex && nextState.outerContext == nextState
+							.remainingOuterContext && dfa.decision >= 0 && !D.configs.HasSemanticContext())
+						{
+							if (t >= 0 && t <= short.MaxValue)
+							{
+								int key = (dfa.decision << 16) + t;
+								atn.LL1Table.Put(key, predictedAlt);
+							}
+						}
+						if (useContext && always_try_local_context)
+						{
+							ReportContextSensitivity(dfa, nextState, startIndex, input.Index());
+						}
+					}
+					else
+					{
+						if (D.configs.GetConflictingAlts() != null)
+						{
+							predictedAlt = D.prediction;
+							//						int k = input.index() - startIndex + 1; // how much input we used
+							//						System.out.println("used k="+k);
+							if (!userWantsCtxSensitive || !D.configs.GetDipsIntoOuterContext() || (treat_sllk1_conflict_as_ambiguity
+								 && input.Index() == startIndex))
+							{
+								if (reportAmbiguities && !D.configs.HasSemanticContext())
+								{
+									ReportAmbiguity(dfa, D, startIndex, input.Index(), D.configs.GetConflictingAlts()
+										, D.configs);
+								}
+							}
+							else
+							{
+								System.Diagnostics.Debug.Assert(!useContext);
+								System.Diagnostics.Debug.Assert(D.isAcceptState);
+								if (D.configs.HasSemanticContext())
+								{
+									int nalts = decState.GetNumberOfTransitions();
+									DFAState.PredPrediction[] predPredictions = D.predicates;
+									if (predPredictions != null)
+									{
+										int conflictIndex = input.Index();
+										if (conflictIndex != startIndex)
+										{
+											input.Seek(startIndex);
+										}
+										// always use complete evaluation here since we'll want to retry with full context if still ambiguous
+										BitSet alts = EvalSemanticContext(predPredictions, outerContext, true);
+										if (alts.Cardinality() == 1)
+										{
+											return alts.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);
+										}
+									}
+								}
+								SimulatorState fullContextState = ComputeStartState(dfa, outerContext, true);
+								if (reportAmbiguities)
+								{
+									ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index());
+								}
+								input.Seek(startIndex);
+								return ExecATN(dfa, input, startIndex, fullContextState);
+							}
+						}
+					}
+					if (D.predicates != null)
+					{
+						int stopIndex = input.Index();
+						if (startIndex != stopIndex)
+						{
+							input.Seek(startIndex);
+						}
+						BitSet alts = EvalSemanticContext(D.predicates, outerContext, reportAmbiguities &&
+							 predictionMode == PredictionMode.LlExactAmbigDetection);
+						D.prediction = ATN.InvalidAltNumber;
+						switch (alts.Cardinality())
+						{
+							case 0:
+							{
+								throw NoViableAlt(input, outerContext, D.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, D, startIndex, stopIndex, alts, D.configs);
+								return alts.NextSetBit(0);
+								break;
+							}
+						}
+					}
+					return predictedAlt;
+				}
+				previous = nextState;
+				if (t != IntStream.Eof)
+				{
+					input.Consume();
+					t = input.La(1);
+				}
+			}
+		}
+
+		protected internal virtual int HandleNoViableAlt(TokenStream input, int startIndex
+			, SimulatorState previous)
+		{
+			if (previous.s0 != null)
+			{
+				BitSet alts = new BitSet();
+				foreach (ATNConfig config in previous.s0.configs)
+				{
+					if (config.GetReachesIntoOuterContext() || config.GetState() is RuleStopState)
+					{
+						alts.Set(config.GetAlt());
+					}
+				}
+				if (!alts.IsEmpty())
+				{
+					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;
+					}
+					remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.GetParent());
+					s = next;
+				}
+			}
+			System.Diagnostics.Debug.Assert(!s.isAcceptState);
+			if (s.isAcceptState)
+			{
+				return new SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext
+					);
+			}
+			DFAState s0 = s;
+			DFAState existingTarget = s0 != null ? s0.GetTarget(t) : null;
+			if (existingTarget != null)
+			{
+				return new SimulatorState(previous.outerContext, existingTarget, useContext, remainingGlobalContext
+					);
+			}
+			IList<ATNConfig> closureConfigs = new AList<ATNConfig>(s0.configs);
+			IntegerList contextElements = null;
+			ATNConfigSet reach = new ATNConfigSet();
+			bool stepIntoGlobal;
+			do
+			{
+				bool hasMoreContext = !useContext || remainingGlobalContext != null;
+				if (!hasMoreContext)
+				{
+					reach.SetOutermostConfigSet(true);
+				}
+				ATNConfigSet reachIntermediate = new ATNConfigSet();
+				IList<ATNConfig> skippedStopStates = null;
+				foreach (ATNConfig c in closureConfigs)
+				{
+					if (c.GetState() is RuleStopState)
+					{
+						System.Diagnostics.Debug.Assert(c.GetContext().IsEmpty());
+						if (useContext && !c.GetReachesIntoOuterContext() || t == IntStream.Eof)
+						{
+							if (skippedStopStates == null)
+							{
+								skippedStopStates = new AList<ATNConfig>();
+							}
+							skippedStopStates.AddItem(c);
+						}
+						continue;
+					}
+					int n = c.GetState().GetNumberOfOptimizedTransitions();
+					for (int ti = 0; ti < n; ti++)
+					{
+						// for each optimized transition
+						Transition trans = c.GetState().GetOptimizedTransition(ti);
+						ATNState target = GetReachableTarget(c, trans, t);
+						if (target != null)
+						{
+							reachIntermediate.Add(c.Transform(target), contextCache);
+						}
+					}
+				}
+				if (optimize_unique_closure && skippedStopStates == null && reachIntermediate.GetUniqueAlt
+					() != ATN.InvalidAltNumber)
+				{
+					reachIntermediate.SetOutermostConfigSet(reach.IsOutermostConfigSet());
+					reach = reachIntermediate;
+					break;
+				}
+				bool collectPredicates = false;
+				Closure(reachIntermediate, reach, collectPredicates, hasMoreContext, contextCache
+					);
+				stepIntoGlobal = reach.GetDipsIntoOuterContext();
+				if (t == IntStream.Eof)
+				{
+					reach = RemoveAllConfigsNotInRuleStopState(reach, contextCache);
+				}
+				if (skippedStopStates != null && (!useContext || !PredictionMode.HasConfigInRuleStopState
+					(reach)))
+				{
+					System.Diagnostics.Debug.Assert(!skippedStopStates.IsEmpty());
+					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 IntegerList();
+					}
+					if (remainingGlobalContext.IsEmpty())
+					{
+						remainingGlobalContext = null;
+					}
+					else
+					{
+						remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.GetParent());
+					}
+					contextElements.Add(nextContextElement);
+					if (nextContextElement != PredictionContext.EmptyFullStateKey)
+					{
+						for (int i = 0; i < closureConfigs.Count; i++)
+						{
+							closureConfigs.Set(i, closureConfigs[i].AppendContext(nextContextElement, contextCache
+								));
+						}
+					}
+				}
+			}
+			while (useContext && stepIntoGlobal);
+			if (reach.IsEmpty())
+			{
+				return null;
+			}
+			DFAState dfaState = null;
+			if (s0 != null)
+			{
+				dfaState = AddDFAEdge(dfa, s0, t, contextElements, reach, contextCache);
+			}
+			System.Diagnostics.Debug.Assert(!useContext || !dfaState.configs.GetDipsIntoOuterContext
+				());
+			return new SimulatorState(previous.outerContext, dfaState, useContext, remainingGlobalContext
+				);
+		}
+
+		/// <summary>
+		/// Return a configuration set containing only the configurations from
+		/// <code>configs</code>
+		/// which are in a
+		/// <see cref="RuleStopState">RuleStopState</see>
+		/// . If all
+		/// configurations in
+		/// <code>configs</code>
+		/// are already in a rule stop state, this
+		/// method simply returns
+		/// <code>configs</code>
+		/// .
+		/// </summary>
+		/// <param name="configs">the configuration set to update</param>
+		/// <param name="contextCache">
+		/// the
+		/// <see cref="PredictionContext">PredictionContext</see>
+		/// cache
+		/// </param>
+		/// <returns>
+		/// 
+		/// <code>configs</code>
+		/// if all configurations in
+		/// <code>configs</code>
+		/// are in a
+		/// rule stop state, otherwise return a new configuration set containing only
+		/// the configurations from
+		/// <code>configs</code>
+		/// which are in a rule stop state
+		/// </returns>
+		[NotNull]
+		protected internal virtual ATNConfigSet RemoveAllConfigsNotInRuleStopState(ATNConfigSet
+			 configs, PredictionContextCache contextCache)
+		{
+			if (PredictionMode.AllConfigsInRuleStopStates(configs))
+			{
+				return configs;
+			}
+			ATNConfigSet result = new ATNConfigSet();
+			foreach (ATNConfig config in configs)
+			{
+				if (!(config.GetState() is RuleStopState))
+				{
+					continue;
+				}
+				result.Add(config, contextCache);
+			}
+			return result;
+		}
+
+		[NotNull]
+		public virtual SimulatorState ComputeStartState(DFA dfa, ParserRuleContext globalContext
+			, bool useContext)
+		{
+			DFAState s0 = useContext ? dfa.s0full.Get() : dfa.s0.Get();
+			if (s0 != null)
+			{
+				if (!useContext)
+				{
+					return new SimulatorState(globalContext, s0, useContext, globalContext);
+				}
+				s0.SetContextSensitive(atn);
+			}
+			int decision = dfa.decision;
+			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)
+			{
+				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.GetParent());
+					}
+					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.GetNumberOfTransitions();
+				for (int ti = 0; ti < n; ti++)
+				{
+					// for each transition
+					ATNState target = p.Transition(ti).target;
+					reachIntermediate.AddItem(ATNConfig.Create(target, ti + 1, initialContext));
+				}
+				bool hasMoreContext = remainingGlobalContext != null;
+				if (!hasMoreContext)
+				{
+					configs.SetOutermostConfigSet(true);
+				}
+				bool collectPredicates = true;
+				Closure(reachIntermediate, configs, collectPredicates, hasMoreContext, contextCache
+					);
+				bool stepIntoGlobal = configs.GetDipsIntoOuterContext();
+				DFAState next = AddDFAState(dfa, configs, contextCache);
+				if (s0 == null)
+				{
+					AtomicReference<DFAState> reference = useContext ? dfa.s0full : dfa.s0;
+					if (!reference.CompareAndSet(null, next))
+					{
+						next = reference.Get();
+					}
+				}
+				else
+				{
+					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.GetParent());
+				}
+				if (nextContextElement != PredictionContext.EmptyFullStateKey)
+				{
+					initialContext = initialContext.AppendContext(nextContextElement, contextCache);
+				}
+				previousContext = nextContextElement;
+			}
+			return new SimulatorState(globalContext, s0, useContext, remainingGlobalContext);
+		}
+
+		[Nullable]
+		public 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>
+		public 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;
+				D.prediction = ATN.InvalidAltNumber;
+			}
+			// make sure we use preds
+			return predPredictions;
+		}
+
+		public 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.GetAlt()))
+				{
+					altToPred[c.GetAlt()] = SemanticContext.Or(altToPred[c.GetAlt()], c.GetSemanticContext
+						());
+				}
+			}
+			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;
+		}
+
+		public virtual DFAState.PredPrediction[] GetPredicatePredictions(BitSet ambigAlts
+			, SemanticContext[] altToPred)
+		{
+			IList<DFAState.PredPrediction> pairs = new AList<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.AddItem(new DFAState.PredPrediction(null, i));
+				}
+				else
+				{
+					if (pred != SemanticContext.None)
+					{
+						containsPredicate = true;
+						pairs.AddItem(new DFAState.PredPrediction(pred, i));
+					}
+				}
+			}
+			if (!containsPredicate)
+			{
+				pairs = null;
+			}
+			//		System.out.println(Arrays.toString(altToPred)+"->"+pairs);
+			return Sharpen.Collections.ToArray(pairs, new DFAState.PredPrediction[pairs.Count
+				]);
+		}
+
+		/// <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
+		/// <code>null</code>
+		/// predicate indicates an alt containing an
+		/// unpredicated config which behaves as "always true."
+		/// </remarks>
+		public virtual BitSet EvalSemanticContext(DFAState.PredPrediction[] predPredictions
+			, ParserRuleContext outerContext, bool complete)
+		{
+			BitSet predictions = new BitSet();
+			foreach (DFAState.PredPrediction pair in predPredictions)
+			{
+				if (pair.pred == null)
+				{
+					predictions.Set(pair.alt);
+					if (!complete)
+					{
+						break;
+					}
+					continue;
+				}
+				bool evaluatedResult = pair.pred.Eval(parser, outerContext);
+				if (debug || dfa_debug)
+				{
+					System.Console.Out.WriteLine("eval pred " + pair + "=" + evaluatedResult);
+				}
+				if (evaluatedResult)
+				{
+					if (debug || dfa_debug)
+					{
+						System.Console.Out.WriteLine("PREDICT " + pair.alt);
+					}
+					predictions.Set(pair.alt);
+					if (!complete)
+					{
+						break;
+					}
+				}
+			}
+			return predictions;
+		}
+
+		protected internal virtual void Closure(ATNConfigSet sourceConfigs, ATNConfigSet 
+			configs, bool collectPredicates, bool hasMoreContext, PredictionContextCache contextCache
+			)
+		{
+			if (contextCache == null)
+			{
+				contextCache = PredictionContextCache.Uncached;
+			}
+			ATNConfigSet currentConfigs = sourceConfigs;
+			ICollection<ATNConfig> closureBusy = new HashSet<ATNConfig>();
+			while (currentConfigs.Count > 0)
+			{
+				ATNConfigSet intermediate = new ATNConfigSet();
+				foreach (ATNConfig config in currentConfigs)
+				{
+					if (optimize_closure_busy && !closureBusy.AddItem(config))
+					{
+						continue;
+					}
+					Closure(config, configs, intermediate, closureBusy, collectPredicates, hasMoreContext
+						, contextCache, 0);
+				}
+				currentConfigs = intermediate;
+			}
+		}
+
+		protected internal virtual void Closure(ATNConfig config, ATNConfigSet configs, ATNConfigSet
+			 intermediate, ICollection<ATNConfig> closureBusy, bool collectPredicates, bool 
+			hasMoreContexts, PredictionContextCache contextCache, int depth)
+		{
+			if (!optimize_closure_busy && !closureBusy.AddItem(config))
+			{
+				return;
+			}
+			// avoid infinite recursion
+			if (config.GetState() is RuleStopState)
+			{
+				// We hit rule end. If we have context info, use it
+				if (!config.GetContext().IsEmpty())
+				{
+					bool hasEmpty = config.GetContext().HasEmpty();
+					int nonEmptySize = config.GetContext().Size() - (hasEmpty ? 1 : 0);
+					for (int i = 0; i < nonEmptySize; i++)
+					{
+						PredictionContext newContext = config.GetContext().GetParent(i);
+						// "pop" return state
+						ATNState returnState = atn.states[config.GetContext().GetReturnState(i)];
+						ATNConfig c = ATNConfig.Create(returnState, config.GetAlt(), newContext, config.GetSemanticContext
+							());
+						// 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.SetOuterContextDepth(config.GetOuterContextDepth());
+						System.Diagnostics.Debug.Assert(depth > int.MinValue);
+						if (optimize_closure_busy && c.GetContext().IsEmpty() && !closureBusy.AddItem(c))
+						{
+							continue;
+						}
+						Closure(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts
+							, contextCache, depth - 1);
+					}
+					if (!hasEmpty || !hasMoreContexts)
+					{
+						return;
+					}
+					config = config.Transform(config.GetState(), PredictionContext.EmptyLocal);
+				}
+				else
+				{
+					if (!hasMoreContexts)
+					{
+						configs.Add(config, contextCache);
+						return;
+					}
+					else
+					{
+						// else if we have no context info, just chase follow links (if greedy)
+						if (config.GetContext() == PredictionContext.EmptyFull)
+						{
+							// no need to keep full context overhead when we step out
+							config = config.Transform(config.GetState(), PredictionContext.EmptyLocal);
+						}
+					}
+				}
+			}
+			ATNState p = config.GetState();
+			// optimization
+			if (!p.OnlyHasEpsilonTransitions())
+			{
+				configs.Add(config, contextCache);
+			}
+			for (int i_1 = 0; i_1 < p.GetNumberOfOptimizedTransitions(); 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
+					);
+				if (c != null)
+				{
+					if (t is Antlr4.Runtime.Atn.RuleTransition)
+					{
+						if (intermediate != null && !collectPredicates)
+						{
+							intermediate.Add(c, contextCache);
+							continue;
+						}
+					}
+					if (optimize_closure_busy)
+					{
+						bool checkClosure = false;
+						switch (c.GetState().GetStateType())
+						{
+							case ATNState.StarLoopEntry:
+							case ATNState.BlockEnd:
+							case ATNState.LoopEnd:
+							{
+								checkClosure = true;
+								break;
+							}
+
+							case ATNState.PlusBlockStart:
+							{
+								checkClosure = true;
+								break;
+							}
+
+							case ATNState.RuleStop:
+							{
+								checkClosure = c.GetContext().IsEmpty();
+								break;
+							}
+
+							default:
+							{
+								break;
+								break;
+							}
+						}
+						if (checkClosure && !closureBusy.AddItem(c))
+						{
+							continue;
+						}
+					}
+					int newDepth = depth;
+					if (config.GetState() 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.
+						c.SetOuterContextDepth(c.GetOuterContextDepth() + 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.GetContext
+								())))
+							{
+								System.Diagnostics.Debug.Assert(c.GetContext() == config.GetContext());
+								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.GetContext(
+										)))
+									{
+										// make sure the SLL config "dips into the outer context" or prediction may not fall back to LL on conflict
+										c.SetOuterContextDepth(c.GetOuterContextDepth() + 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);
+				}
+			}
+		}
+
+		[NotNull]
+		public virtual string GetRuleName(int index)
+		{
+			if (parser != null && index >= 0)
+			{
+				return parser.GetRuleNames()[index];
+			}
+			return "<rule " + index + ">";
+		}
+
+		[Nullable]
+		public virtual ATNConfig GetEpsilonTarget(ATNConfig config, Transition t, bool collectPredicates
+			, bool inContext, PredictionContextCache contextCache)
+		{
+			switch (t.GetSerializationType())
+			{
+				case Transition.Rule:
+				{
+					return RuleTransition(config, (Antlr4.Runtime.Atn.RuleTransition)t, contextCache);
+				}
+
+				case Transition.Precedence:
+				{
+					return PrecedenceTransition(config, (PrecedencePredicateTransition)t, collectPredicates
+						, inContext);
+				}
+
+				case Transition.Predicate:
+				{
+					return PredTransition(config, (PredicateTransition)t, collectPredicates, inContext
+						);
+				}
+
+				case Transition.Action:
+				{
+					return ActionTransition(config, (Antlr4.Runtime.Atn.ActionTransition)t);
+				}
+
+				case Transition.Epsilon:
+				{
+					return config.Transform(t.target);
+				}
+
+				default:
+				{
+					return null;
+					break;
+				}
+			}
+		}
+
+		[NotNull]
+		public virtual ATNConfig ActionTransition(ATNConfig config, Antlr4.Runtime.Atn.ActionTransition
+			 t)
+		{
+			return config.Transform(t.target);
+		}
+
+		[Nullable]
+		public virtual ATNConfig PrecedenceTransition(ATNConfig config, PrecedencePredicateTransition
+			 pt, bool collectPredicates, bool inContext)
+		{
+			ATNConfig c = null;
+			if (collectPredicates && inContext)
+			{
+				SemanticContext newSemCtx = SemanticContext.And(config.GetSemanticContext(), pt.GetPredicate
+					());
+				c = config.Transform(pt.target, newSemCtx);
+			}
+			else
+			{
+				c = config.Transform(pt.target);
+			}
+			return c;
+		}
+
+		[Nullable]
+		public virtual ATNConfig PredTransition(ATNConfig config, PredicateTransition pt, 
+			bool collectPredicates, bool inContext)
+		{
+			ATNConfig c;
+			if (collectPredicates && (!pt.isCtxDependent || (pt.isCtxDependent && inContext)))
+			{
+				SemanticContext newSemCtx = SemanticContext.And(config.GetSemanticContext(), pt.GetPredicate
+					());
+				c = config.Transform(pt.target, newSemCtx);
+			}
+			else
+			{
+				c = config.Transform(pt.target);
+			}
+			return c;
+		}
+
+		[NotNull]
+		public 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.GetContext())))
+			{
+				newContext = config.GetContext();
+			}
+			else
+			{
+				if (contextCache != null)
+				{
+					newContext = contextCache.GetChild(config.GetContext(), returnState.stateNumber);
+				}
+				else
+				{
+					newContext = config.GetContext().GetChild(returnState.stateNumber);
+				}
+			}
+			return config.Transform(t.target, newContext);
+		}
+
+		private sealed class _IComparer_1557 : IComparer<ATNConfig>
+		{
+			public _IComparer_1557()
+			{
+			}
+
+			public int Compare(ATNConfig o1, ATNConfig o2)
+			{
+				int diff = o1.GetState().GetNonStopStateNumber() - o2.GetState().GetNonStopStateNumber
+					();
+				if (diff != 0)
+				{
+					return diff;
+				}
+				diff = o1.GetAlt() - o2.GetAlt();
+				if (diff != 0)
+				{
+					return diff;
+				}
+				return 0;
+			}
+		}
+
+		private static readonly IComparer<ATNConfig> StateAltSortComparator = new _IComparer_1557
+			();
+
+		private BitSet IsConflicted(ATNConfigSet configset, PredictionContextCache contextCache
+			)
+		{
+			if (configset.GetUniqueAlt() != ATN.InvalidAltNumber || configset.Count <= 1)
+			{
+				return null;
+			}
+			IList<ATNConfig> configs = new AList<ATNConfig>(configset);
+			configs.Sort(StateAltSortComparator);
+			bool exact = !configset.GetDipsIntoOuterContext() && predictionMode == PredictionMode
+				.LlExactAmbigDetection;
+			BitSet alts = new BitSet();
+			int minAlt = configs[0].GetAlt();
+			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].GetState().GetNonStopStateNumber();
+			for (int i = 0; i < configs.Count; i++)
+			{
+				ATNConfig config = configs[i];
+				int stateNumber = config.GetState().GetNonStopStateNumber();
+				if (stateNumber != currentState)
+				{
+					if (config.GetAlt() != minAlt)
+					{
+						return null;
+					}
+					currentState = stateNumber;
+				}
+			}
+			BitSet representedAlts = null;
+			if (exact)
+			{
+				currentState = configs[0].GetState().GetNonStopStateNumber();
+				// get the represented alternatives of the first state
+				representedAlts = new BitSet();
+				int maxAlt = minAlt;
+				for (int i_1 = 0; i_1 < configs.Count; i_1++)
+				{
+					ATNConfig config = configs[i_1];
+					if (config.GetState().GetNonStopStateNumber() != currentState)
+					{
+						break;
+					}
+					int alt = config.GetAlt();
+					representedAlts.Set(alt);
+					maxAlt = alt;
+				}
+				// quick check #3:
+				currentState = configs[0].GetState().GetNonStopStateNumber();
+				int currentAlt = minAlt;
+				for (int i_2 = 0; i_2 < configs.Count; i_2++)
+				{
+					ATNConfig config = configs[i_2];
+					int stateNumber = config.GetState().GetNonStopStateNumber();
+					int alt = config.GetAlt();
+					if (stateNumber != currentState)
+					{
+						if (currentAlt != maxAlt)
+						{
+							return null;
+						}
+						currentState = stateNumber;
+						currentAlt = minAlt;
+					}
+					else
+					{
+						if (alt != currentAlt)
+						{
+							if (alt != representedAlts.NextSetBit(currentAlt + 1))
+							{
+								return null;
+							}
+							currentAlt = alt;
+						}
+					}
+				}
+			}
+			currentState = configs[0].GetState().GetNonStopStateNumber();
+			int firstIndexCurrentState = 0;
+			int lastIndexCurrentStateMinAlt = 0;
+			PredictionContext joinedCheckContext = configs[0].GetContext();
+			for (int i_3 = 1; i_3 < configs.Count; i_3++)
+			{
+				ATNConfig config = configs[i_3];
+				if (config.GetAlt() != minAlt)
+				{
+					break;
+				}
+				if (config.GetState().GetNonStopStateNumber() != currentState)
+				{
+					break;
+				}
+				lastIndexCurrentStateMinAlt = i_3;
+				joinedCheckContext = contextCache.Join(joinedCheckContext, configs[i_3].GetContext
+					());
+			}
+			for (int i_4 = lastIndexCurrentStateMinAlt + 1; i_4 < configs.Count; i_4++)
+			{
+				ATNConfig config = configs[i_4];
+				ATNState state = config.GetState();
+				alts.Set(config.GetAlt());
+				if (state.GetNonStopStateNumber() != currentState)
+				{
+					currentState = state.GetNonStopStateNumber();
+					firstIndexCurrentState = i_4;
+					lastIndexCurrentStateMinAlt = i_4;
+					joinedCheckContext = config.GetContext();
+					for (int j = firstIndexCurrentState + 1; j < configs.Count; j++)
+					{
+						ATNConfig config2 = configs[j];
+						if (config2.GetAlt() != minAlt)
+						{
+							break;
+						}
+						if (config2.GetState().GetNonStopStateNumber() != currentState)
+						{
+							break;
+						}
+						lastIndexCurrentStateMinAlt = j;
+						joinedCheckContext = contextCache.Join(joinedCheckContext, config2.GetContext());
+					}
+					i_4 = lastIndexCurrentStateMinAlt;
+					continue;
+				}
+				PredictionContext joinedCheckContext2 = config.GetContext();
+				int currentAlt = config.GetAlt();
+				int lastIndexCurrentStateCurrentAlt = i_4;
+				for (int j_1 = lastIndexCurrentStateCurrentAlt + 1; j_1 < configs.Count; j_1++)
+				{
+					ATNConfig config2 = configs[j_1];
+					if (config2.GetAlt() != currentAlt)
+					{
+						break;
+					}
+					if (config2.GetState().GetNonStopStateNumber() != currentState)
+					{
+						break;
+					}
+					lastIndexCurrentStateCurrentAlt = j_1;
+					joinedCheckContext2 = contextCache.Join(joinedCheckContext2, config2.GetContext()
+						);
+				}
+				i_4 = lastIndexCurrentStateCurrentAlt;
+				if (exact)
+				{
+					if (!joinedCheckContext.Equals(joinedCheckContext2))
+					{
+						return null;
+					}
+				}
+				else
+				{
+					PredictionContext check = contextCache.Join(joinedCheckContext, joinedCheckContext2
+						);
+					if (!joinedCheckContext.Equals(check))
+					{
+						return null;
+					}
+				}
+				if (!exact && optimize_hidden_conflicted_configs)
+				{
+					for (int j = firstIndexCurrentState; j_1 <= lastIndexCurrentStateMinAlt; j_1++)
+					{
+						ATNConfig checkConfig = configs[j_1];
+						if (checkConfig.GetSemanticContext() != SemanticContext.None && !checkConfig.GetSemanticContext
+							().Equals(config.GetSemanticContext()))
+						{
+							continue;
+						}
+						if (joinedCheckContext != checkConfig.GetContext())
+						{
+							PredictionContext check = contextCache.Join(checkConfig.GetContext(), config.GetContext
+								());
+							if (!checkConfig.GetContext().Equals(check))
+							{
+								continue;
+							}
+						}
+						config.SetHidden(true);
+					}
+				}
+			}
+			return alts;
+		}
+
+		protected internal virtual BitSet GetConflictingAltsFromConfigSet(ATNConfigSet configs
+			)
+		{
+			BitSet conflictingAlts = configs.GetConflictingAlts();
+			if (conflictingAlts == null && configs.GetUniqueAlt() != ATN.InvalidAltNumber)
+			{
+				conflictingAlts = new BitSet();
+				conflictingAlts.Set(configs.GetUniqueAlt());
+			}
+			return conflictingAlts;
+		}
+
+		protected internal virtual int ResolveToMinAlt(DFAState D, BitSet conflictingAlts
+			)
+		{
+			// kill dead alts so we don't chase them ever
+			//		killAlts(conflictingAlts, D.configset);
+			D.prediction = conflictingAlts.NextSetBit(0);
+			return D.prediction;
+		}
+
+		[NotNull]
+		public virtual 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.Console.Error.WriteLine(t + " ttype out of range: " + Arrays.ToString(tokensNames
+						));
+					System.Console.Error.WriteLine(((CommonTokenStream)((TokenStream)parser.GetInputStream
+						())).GetTokens());
+				}
+				else
+				{
+					return tokensNames[t] + "<" + t + ">";
+				}
+			}
+			return t.ToString();
+		}
+
+		public virtual string GetLookaheadName(TokenStream input)
+		{
+			return GetTokenName(input.La(1));
+		}
+
+		public virtual void DumpDeadEndConfigs(NoViableAltException nvae)
+		{
+			System.Console.Error.WriteLine("dead end configs: ");
+			foreach (ATNConfig c in nvae.GetDeadEndConfigs())
+			{
+				string trans = "no edges";
+				if (c.GetState().GetNumberOfOptimizedTransitions() > 0)
+				{
+					Transition t = c.GetState().GetOptimizedTransition(0);
+					if (t is AtomTransition)
+					{
+						AtomTransition at = (AtomTransition)t;
+						trans = "Atom " + GetTokenName(at.label);
+					}
+					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);
+			}
+		}
+
+		[NotNull]
+		public virtual NoViableAltException NoViableAlt(TokenStream input, ParserRuleContext
+			 outerContext, ATNConfigSet configs, int startIndex)
+		{
+			return new NoViableAltException(parser, input, input.Get(startIndex), input.Lt(1)
+				, configs, outerContext);
+		}
+
+		public virtual int GetUniqueAlt(ICollection<ATNConfig> configs)
+		{
+			int alt = ATN.InvalidAltNumber;
+			foreach (ATNConfig c in configs)
+			{
+				if (alt == ATN.InvalidAltNumber)
+				{
+					alt = c.GetAlt();
+				}
+				else
+				{
+					// found first alt
+					if (c.GetAlt() != alt)
+					{
+						return ATN.InvalidAltNumber;
+					}
+				}
+			}
+			return alt;
+		}
+
+		public virtual bool ConfigWithAltAtStopState(ICollection<ATNConfig> configs, int 
+			alt)
+		{
+			foreach (ATNConfig c in configs)
+			{
+				if (c.GetAlt() == alt)
+				{
+					if (c.GetState() is RuleStopState)
+					{
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+		[NotNull]
+		protected internal virtual DFAState AddDFAEdge(DFA dfa, DFAState fromState, int t
+			, IntegerList contextTransitions, ATNConfigSet toConfigs, PredictionContextCache
+			 contextCache)
+		{
+			System.Diagnostics.Debug.Assert(dfa.IsContextSensitive() || contextTransitions ==
+				 null || contextTransitions.IsEmpty());
+			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>
+		[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.AddItem(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.SetOutermostConfigSet(true);
+				return AddDFAState(dfa, configs, contextCache);
+			}
+		}
+
+		/// <summary>See comment on LexerInterpreter.addDFAState.</summary>
+		/// <remarks>See comment on LexerInterpreter.addDFAState.</remarks>
+		[NotNull]
+		protected internal virtual DFAState AddDFAState(DFA dfa, ATNConfigSet configs, PredictionContextCache
+			 contextCache)
+		{
+			if (!configs.IsReadOnly())
+			{
+				configs.OptimizeConfigs(this);
+			}
+			DFAState proposed = CreateDFAState(configs);
+			DFAState existing = dfa.states.Get(proposed);
+			if (existing != null)
+			{
+				return existing;
+			}
+			if (!configs.IsReadOnly())
+			{
+				if (configs.GetConflictingAlts() == null)
+				{
+					configs.SetConflictingAlts(IsConflicted(configs, contextCache));
+					if (optimize_hidden_conflicted_configs && configs.GetConflictingAlts() != null)
+					{
+						int size = configs.Count;
+						configs.StripHiddenConfigs();
+						if (configs.Count < size)
+						{
+							proposed = CreateDFAState(configs);
+							existing = dfa.states.Get(proposed);
+							if (existing != null)
+							{
+								return existing;
+							}
+						}
+					}
+				}
+			}
+			DFAState newState = CreateDFAState(configs.Clone(true));
+			DecisionState decisionState = atn.GetDecisionState(dfa.decision);
+			int predictedAlt = GetUniqueAlt(configs);
+			if (predictedAlt != ATN.InvalidAltNumber)
+			{
+				newState.isAcceptState = true;
+				newState.prediction = predictedAlt;
+			}
+			else
+			{
+				if (configs.GetConflictingAlts() != null)
+				{
+					newState.isAcceptState = true;
+					newState.prediction = ResolveToMinAlt(newState, newState.configs.GetConflictingAlts
+						());
+				}
+			}
+			if (newState.isAcceptState && configs.HasSemanticContext())
+			{
+				PredicateDFAState(newState, configs, decisionState.GetNumberOfTransitions());
+			}
+			DFAState added = dfa.AddState(newState);
+			if (debug && added == newState)
+			{
+				System.Console.Out.WriteLine("adding new DFA state: " + newState);
+			}
+			return added;
+		}
+
+		[NotNull]
+		protected internal virtual DFAState CreateDFAState(ATNConfigSet configs)
+		{
+			return new DFAState(configs, -1, atn.maxTokenType);
+		}
+
+		//	public void reportConflict(int startIndex, int stopIndex,
+		//							   @NotNull IntervalSet alts,
+		//							   @NotNull ATNConfigSet configs)
+		//	{
+		//		if ( debug || retry_debug ) {
+		//			System.out.println("reportConflict "+alts+":"+configs+
+		//							   ", input="+parser.getInputString(startIndex, stopIndex));
+		//		}
+		//		if ( parser!=null ) parser.getErrorHandler().reportConflict(parser, startIndex, stopIndex, alts, configs);
+		//	}
+		public virtual void ReportAttemptingFullContext(DFA dfa, SimulatorState initialState
+			, int startIndex, int stopIndex)
+		{
+			if (debug || retry_debug)
+			{
+				Interval interval = Interval.Of(startIndex, stopIndex);
+				System.Console.Out.WriteLine("reportAttemptingFullContext decision=" + dfa.decision
+					 + ":" + initialState.s0.configs + ", input=" + ((TokenStream)parser.GetInputStream
+					()).GetText(interval));
+			}
+			if (parser != null)
+			{
+				((ParserErrorListener)parser.GetErrorListenerDispatch()).ReportAttemptingFullContext
+					(parser, dfa, startIndex, stopIndex, initialState);
+			}
+		}
+
+		public virtual void ReportContextSensitivity(DFA dfa, SimulatorState acceptState, 
+			int startIndex, int stopIndex)
+		{
+			if (debug || retry_debug)
+			{
+				Interval interval = Interval.Of(startIndex, stopIndex);
+				System.Console.Out.WriteLine("reportContextSensitivity decision=" + dfa.decision 
+					+ ":" + acceptState.s0.configs + ", input=" + ((TokenStream)parser.GetInputStream
+					()).GetText(interval));
+			}
+			if (parser != null)
+			{
+				((ParserErrorListener)parser.GetErrorListenerDispatch()).ReportContextSensitivity
+					(parser, dfa, startIndex, stopIndex, acceptState);
+			}
+		}
+
+		/// <summary>If context sensitive parsing, we know it's ambiguity not conflict</summary>
+		public virtual void ReportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex
+			, BitSet ambigAlts, ATNConfigSet configs)
+		{
+			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.Console.Out.WriteLine("reportAmbiguity " + ambigAlts + ":" + configs + ", input="
+					 + ((TokenStream)parser.GetInputStream()).GetText(interval));
+			}
+			if (parser != null)
+			{
+				((ParserErrorListener)parser.GetErrorListenerDispatch()).ReportAmbiguity(parser, 
+					dfa, startIndex, stopIndex, 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.GetNumberOfTransitions() == 1 && state.Transition
+					(0).GetSerializationType() == Transition.Rule);
+				Antlr4.Runtime.Atn.RuleTransition transition = (Antlr4.Runtime.Atn.RuleTransition
+					)state.Transition(0);
+				if (!transition.tailCall)
+				{
+					break;
+				}
+				context = ((ParserRuleContext)context.GetParent());
+			}
+			return context;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/PlusBlockStartState.cs b/Antlr4.Runtime/Atn/PlusBlockStartState.cs
new file mode 100644
index 000000000..bd91c5fe7
--- /dev/null
+++ b/Antlr4.Runtime/Atn/PlusBlockStartState.cs
@@ -0,0 +1,56 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>
+	/// Start of
+	/// <code>(A|B|...)+</code>
+	/// 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">PlusLoopbackState</see>
+	/// node is the
+	/// real decision-making note for
+	/// <code>A+</code>
+	/// .
+	/// </summary>
+	public sealed class PlusBlockStartState : BlockStartState
+	{
+		public PlusLoopbackState loopBackState;
+
+		public override int GetStateType()
+		{
+			return PlusBlockStart;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/PlusLoopbackState.cs b/Antlr4.Runtime/Atn/PlusLoopbackState.cs
new file mode 100644
index 000000000..6a98bb44b
--- /dev/null
+++ b/Antlr4.Runtime/Atn/PlusLoopbackState.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.Atn;
+using Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>
+	/// Decision state for
+	/// <code>A+</code>
+	/// and
+	/// <code>(A|B)+</code>
+	/// .  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 int GetStateType()
+		{
+			return PlusLoopBack;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs b/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
new file mode 100644
index 000000000..ec5e4c2fc
--- /dev/null
+++ b/Antlr4.Runtime/Atn/PrecedencePredicateTransition.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 Antlr4.Runtime.Atn;
+using 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 int GetSerializationType()
+		{
+			return Precedence;
+		}
+
+		public override bool IsEpsilon()
+		{
+			return true;
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return false;
+		}
+
+		public SemanticContext.PrecedencePredicate GetPredicate()
+		{
+			return new SemanticContext.PrecedencePredicate(precedence);
+		}
+
+		public override string ToString()
+		{
+			return precedence + " >= _p";
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/PredicateTransition.cs b/Antlr4.Runtime/Atn/PredicateTransition.cs
new file mode 100644
index 000000000..4857c87f1
--- /dev/null
+++ b/Antlr4.Runtime/Atn/PredicateTransition.cs
@@ -0,0 +1,90 @@
+/*
+ * [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 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 int GetSerializationType()
+		{
+			return Predicate;
+		}
+
+		public override bool IsEpsilon()
+		{
+			return true;
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return false;
+		}
+
+		public SemanticContext.Predicate GetPredicate()
+		{
+			return new SemanticContext.Predicate(ruleIndex, predIndex, isCtxDependent);
+		}
+
+		[NotNull]
+		public override string ToString()
+		{
+			return "pred_" + ruleIndex + ":" + predIndex;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/PredictionContext.cs b/Antlr4.Runtime/Atn/PredictionContext.cs
new file mode 100644
index 000000000..0a1e6361b
--- /dev/null
+++ b/Antlr4.Runtime/Atn/PredictionContext.cs
@@ -0,0 +1,542 @@
+/*
+ * [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 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;
+
+		private const int HashMultiplier = 31;
+
+		/// <summary>Stores the computed hash code of this PredictionContext.</summary>
+		/// <remarks>
+		/// Stores the computed hash code of this PredictionContext. The hash code is
+		/// computed in parts to match the following reference algorithm.
+		/// <pre>
+		/// private int referenceHashCode() {
+		/// int returnStateHashCode =
+		/// <see cref="InitialHash">INITIAL_HASH</see>
+		/// ;
+		/// for (int i = 0; i &lt; size(); i++) {
+		/// returnStateHashCode = returnStateHashCode *
+		/// <see cref="HashMultiplier">HASH_MULTIPLIER</see>
+		/// ^ getReturnState(i);
+		/// }
+		/// int parentHashCode = INITIAL_HASH;
+		/// for (int i = 0; i &lt; size(); i++) {
+		/// parentHashCode = parentHashCode * HASH_MULTIPLIER ^ getParent(i).hashCode();
+		/// }
+		/// int hashCode = INITIAL_HASH;
+		/// hashCode = hashCode * HASH_MULTIPLIER ^ parentHashCode;
+		/// hashCode = hashCode * HASH_MULTIPLIER ^ returnStateHashCode;
+		/// return hashCode;
+		/// }
+		/// </pre>
+		/// </remarks>
+		private readonly int cachedHashCode;
+
+		protected internal PredictionContext(int cachedHashCode)
+		{
+			this.cachedHashCode = cachedHashCode;
+		}
+
+		protected internal static int CalculateEmptyParentHashCode()
+		{
+			return InitialHash;
+		}
+
+		protected internal static int CalculateParentHashCode(Antlr4.Runtime.Atn.PredictionContext
+			 parent)
+		{
+			return InitialHash * HashMultiplier ^ parent.GetHashCode();
+		}
+
+		protected internal static int CalculateParentHashCode(Antlr4.Runtime.Atn.PredictionContext
+			[] parents)
+		{
+			int hashCode = InitialHash;
+			foreach (Antlr4.Runtime.Atn.PredictionContext context in parents)
+			{
+				hashCode = hashCode * HashMultiplier ^ context.GetHashCode();
+			}
+			return hashCode;
+		}
+
+		protected internal static int CalculateEmptyReturnStateHashCode()
+		{
+			return InitialHash;
+		}
+
+		protected internal static int CalculateReturnStateHashCode(int returnState)
+		{
+			return InitialHash * HashMultiplier ^ returnState;
+		}
+
+		protected internal static int CalculateReturnStatesHashCode(int[] returnStates)
+		{
+			int hashCode = InitialHash;
+			foreach (int state in returnStates)
+			{
+				hashCode = hashCode * HashMultiplier ^ state;
+			}
+			return hashCode;
+		}
+
+		protected internal static int CalculateHashCode(int parentHashCode, int returnStateHashCode
+			)
+		{
+			return (InitialHash * HashMultiplier ^ parentHashCode) * HashMultiplier ^ returnStateHashCode;
+		}
+
+		public abstract int Size();
+
+		public abstract int GetReturnState(int index);
+
+		public abstract int FindReturnState(int returnState);
+
+		[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, ConcurrentMap<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext
+			> contextCache, PredictionContext.IdentityHashMap visited)
+		{
+			if (context.IsEmpty())
+			{
+				return context;
+			}
+			Antlr4.Runtime.Atn.PredictionContext existing = visited.Get(context);
+			if (existing != null)
+			{
+				return existing;
+			}
+			existing = contextCache.Get(context);
+			if (existing != null)
+			{
+				visited.Put(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.PutIfAbsent(context, context);
+				visited.Put(context, existing != null ? existing : context);
+				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.PutIfAbsent(updated, updated);
+			visited.Put(updated, existing != null ? existing : updated);
+			visited.Put(context, existing != null ? existing : updated);
+			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();
+
+		public abstract bool HasEmpty();
+
+		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<_T0>(Recognizer<_T0> recognizer, int currentState
+			)
+		{
+			return ToStrings(recognizer, Antlr4.Runtime.Atn.PredictionContext.EmptyFull, currentState
+				);
+		}
+
+		public virtual string[] ToStrings<_T0>(Recognizer<_T0> recognizer, Antlr4.Runtime.Atn.PredictionContext
+			 stop, int currentState)
+		{
+			IList<string> result = new AList<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.GetATN();
+						ATNState s = atn.states[stateNumber];
+						string ruleName = recognizer.GetRuleNames()[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.AddItem(localBuffer.ToString());
+				if (last)
+				{
+					break;
+				}
+outer_continue: ;
+			}
+outer_break: ;
+			return Sharpen.Collections.ToArray(result, new string[result.Count]);
+		}
+
+		public sealed class IdentityHashMap : FlexibleHashMap<PredictionContext, PredictionContext
+			>
+		{
+			public IdentityHashMap() : base(PredictionContext.IdentityEqualityComparator.Instance
+				)
+			{
+			}
+		}
+
+		public sealed class IdentityEqualityComparator : AbstractEqualityComparator<PredictionContext
+			>
+		{
+			public static readonly PredictionContext.IdentityEqualityComparator Instance = new 
+				PredictionContext.IdentityEqualityComparator();
+
+			public IdentityEqualityComparator()
+			{
+			}
+
+			public override int HashCode(PredictionContext obj)
+			{
+				return obj.GetHashCode();
+			}
+
+			public override bool Equals(PredictionContext a, PredictionContext b)
+			{
+				return a == b;
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/PredictionContextCache.cs b/Antlr4.Runtime/Atn/PredictionContextCache.cs
new file mode 100644
index 000000000..90c93b3df
--- /dev/null
+++ b/Antlr4.Runtime/Atn/PredictionContextCache.cs
@@ -0,0 +1,212 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	/// <summary>
+	/// Used to cache
+	/// <see cref="PredictionContext">PredictionContext</see>
+	/// 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 = contexts.Get(context);
+			if (result == null)
+			{
+				result = context;
+				contexts.Put(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 = childContexts.Get(operands);
+			if (result == null)
+			{
+				result = context.GetChild(invokingState);
+				result = GetAsCached(result);
+				childContexts.Put(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 = joinContexts.Get(operands);
+			if (result != null)
+			{
+				return result;
+			}
+			result = PredictionContext.Join(x, y, this);
+			result = GetAsCached(result);
+			joinContexts.Put(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 GetX()
+			{
+				return x;
+			}
+
+			public PredictionContext GetY()
+			{
+				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/Antlr4.Runtime/Atn/RangeTransition.cs b/Antlr4.Runtime/Atn/RangeTransition.cs
new file mode 100644
index 000000000..05fb2d46c
--- /dev/null
+++ b/Antlr4.Runtime/Atn/RangeTransition.cs
@@ -0,0 +1,70 @@
+/*
+ * [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 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 int GetSerializationType()
+		{
+			return Range;
+		}
+
+		[NotNull]
+		public override IntervalSet Label()
+		{
+			return IntervalSet.Of(from, to);
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return symbol >= from && symbol <= to;
+		}
+
+		[NotNull]
+		public override string ToString()
+		{
+			return "'" + (char)from + "'..'" + (char)to + "'";
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/RuleStartState.cs b/Antlr4.Runtime/Atn/RuleStartState.cs
new file mode 100644
index 000000000..dfce3af19
--- /dev/null
+++ b/Antlr4.Runtime/Atn/RuleStartState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public sealed class RuleStartState : ATNState
+	{
+		public RuleStopState stopState;
+
+		public bool isPrecedenceRule;
+
+		public bool leftFactored;
+
+		public override int GetStateType()
+		{
+			return RuleStart;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/RuleStopState.cs b/Antlr4.Runtime/Atn/RuleStopState.cs
new file mode 100644
index 000000000..e9dae9234
--- /dev/null
+++ b/Antlr4.Runtime/Atn/RuleStopState.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.Atn;
+using 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 GetNonStopStateNumber()
+		{
+			return -1;
+		}
+
+		public override int GetStateType()
+		{
+			return RuleStop;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/RuleTransition.cs b/Antlr4.Runtime/Atn/RuleTransition.cs
new file mode 100644
index 000000000..a1eb5a4ed
--- /dev/null
+++ b/Antlr4.Runtime/Atn/RuleTransition.cs
@@ -0,0 +1,75 @@
+/*
+ * [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 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;
+
+		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 int GetSerializationType()
+		{
+			return Rule;
+		}
+
+		public override bool IsEpsilon()
+		{
+			return true;
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return false;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/SemanticContext.cs b/Antlr4.Runtime/Atn/SemanticContext.cs
new file mode 100644
index 000000000..11038dcbb
--- /dev/null
+++ b/Antlr4.Runtime/Atn/SemanticContext.cs
@@ -0,0 +1,418 @@
+/*
+ * [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.Misc;
+using 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
+	/// <code>p1&&p2</code>
+	/// , or a sum of products
+	/// <code>p1||p2</code>
+	/// .
+	/// <p/>
+	/// I have scoped the
+	/// <see cref="AND">AND</see>
+	/// ,
+	/// <see cref="OR">OR</see>
+	/// , and
+	/// <see cref="Predicate">Predicate</see>
+	/// subclasses of
+	/// <see cref="SemanticContext">SemanticContext</see>
+	/// within the scope of this outer class.
+	/// </remarks>
+	public abstract class SemanticContext
+	{
+		public static readonly SemanticContext None = new SemanticContext.Predicate();
+
+		public SemanticContext parent;
+
+		/// <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.
+		/// </remarks>
+		public abstract bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext);
+
+		public class Predicate : SemanticContext
+		{
+			public readonly int ruleIndex;
+
+			public readonly int predIndex;
+
+			public readonly bool isCtxDependent;
+
+			public 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<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+			{
+				RuleContext localctx = isCtxDependent ? outerContext : null;
+				return parser.Sempred(localctx, ruleIndex, predIndex);
+			}
+
+			public override int GetHashCode()
+			{
+				int hashCode = 1;
+				hashCode = 31 * hashCode + ruleIndex;
+				hashCode = 31 * hashCode + predIndex;
+				hashCode = 31 * hashCode + (isCtxDependent ? 1 : 0);
+				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, Comparable<SemanticContext.PrecedencePredicate
+			>
+		{
+			public readonly int precedence;
+
+			public PrecedencePredicate()
+			{
+				this.precedence = 0;
+			}
+
+			public PrecedencePredicate(int precedence)
+			{
+				this.precedence = precedence;
+			}
+
+			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+			{
+				return parser.Precpred(outerContext, precedence);
+			}
+
+			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()
+			{
+				return base.ToString();
+			}
+		}
+
+		public class AND : SemanticContext
+		{
+			[NotNull]
+			public readonly SemanticContext[] opnds;
+
+			public AND(SemanticContext a, SemanticContext b)
+			{
+				ICollection<SemanticContext> operands = new HashSet<SemanticContext>();
+				if (a is SemanticContext.AND)
+				{
+					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.AND)a).opnds
+						));
+				}
+				else
+				{
+					operands.AddItem(a);
+				}
+				if (b is SemanticContext.AND)
+				{
+					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.AND)b).opnds
+						));
+				}
+				else
+				{
+					operands.AddItem(b);
+				}
+				IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates
+					(operands);
+				if (!precedencePredicates.IsEmpty())
+				{
+					// interested in the transition with the lowest precedence
+					SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Min(precedencePredicates
+						);
+					operands.AddItem(reduced);
+				}
+				opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count]
+					);
+			}
+
+			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 Arrays.HashCode(opnds);
+			}
+
+			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+			{
+				foreach (SemanticContext opnd in opnds)
+				{
+					if (!opnd.Eval(parser, outerContext))
+					{
+						return false;
+					}
+				}
+				return true;
+			}
+
+			public override string ToString()
+			{
+				return Utils.Join(opnds, "&&");
+			}
+		}
+
+		public class OR : SemanticContext
+		{
+			[NotNull]
+			public readonly SemanticContext[] opnds;
+
+			public OR(SemanticContext a, SemanticContext b)
+			{
+				ICollection<SemanticContext> operands = new HashSet<SemanticContext>();
+				if (a is SemanticContext.OR)
+				{
+					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.OR)a).opnds)
+						);
+				}
+				else
+				{
+					operands.AddItem(a);
+				}
+				if (b is SemanticContext.OR)
+				{
+					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.OR)b).opnds)
+						);
+				}
+				else
+				{
+					operands.AddItem(b);
+				}
+				IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates
+					(operands);
+				if (!precedencePredicates.IsEmpty())
+				{
+					// interested in the transition with the highest precedence
+					SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Max(precedencePredicates
+						);
+					operands.AddItem(reduced);
+				}
+				this.opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count
+					]);
+			}
+
+			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 Arrays.HashCode(opnds) + 1;
+			}
+
+			// differ from AND slightly
+			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+			{
+				foreach (SemanticContext opnd in opnds)
+				{
+					if (opnd.Eval(parser, outerContext))
+					{
+						return true;
+					}
+				}
+				return false;
+			}
+
+			public override string ToString()
+			{
+				return Utils.Join(opnds, "||");
+			}
+		}
+
+		public static SemanticContext And(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(Sharpen.BitSet, ATNConfigSet, int)
+		/// 	">ParserATNSimulator.GetPredsForAmbigAlts(Sharpen.BitSet, ATNConfigSet, int)</seealso>
+		public static SemanticContext Or(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
+			<_T0>(ICollection<_T0> collection) where _T0:SemanticContext
+		{
+			AList<SemanticContext.PrecedencePredicate> result = null;
+			for (IEnumerator<SemanticContext> iterator = collection.GetEnumerator(); iterator
+				.HasNext(); )
+			{
+				SemanticContext context = iterator.Next();
+				if (context is SemanticContext.PrecedencePredicate)
+				{
+					if (result == null)
+					{
+						result = new AList<SemanticContext.PrecedencePredicate>();
+					}
+					result.AddItem((SemanticContext.PrecedencePredicate)context);
+					iterator.Remove();
+				}
+			}
+			if (result == null)
+			{
+				return Sharpen.Collections.EmptyList();
+			}
+			return result;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/SetTransition.cs b/Antlr4.Runtime/Atn/SetTransition.cs
new file mode 100644
index 000000000..b84526e0a
--- /dev/null
+++ b/Antlr4.Runtime/Atn/SetTransition.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;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using 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(Token.InvalidType);
+			}
+			this.set = set;
+		}
+
+		public override int GetSerializationType()
+		{
+			return Set;
+		}
+
+		[NotNull]
+		public override IntervalSet Label()
+		{
+			return set;
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return set.Contains(symbol);
+		}
+
+		[NotNull]
+		public override string ToString()
+		{
+			return set.ToString();
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/SimulatorState.cs b/Antlr4.Runtime/Atn/SimulatorState.cs
new file mode 100644
index 000000000..138f95567
--- /dev/null
+++ b/Antlr4.Runtime/Atn/SimulatorState.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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Dfa;
+using 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/Antlr4.Runtime/Atn/SingletonPredictionContext.cs b/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
new file mode 100644
index 000000000..005ac3635
--- /dev/null
+++ b/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
@@ -0,0 +1,126 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public class SingletonPredictionContext : PredictionContext
+	{
+		[NotNull]
+		public readonly PredictionContext parent;
+
+		public readonly int returnState;
+
+		internal SingletonPredictionContext(PredictionContext parent, int returnState) : 
+			base(CalculateHashCode(CalculateParentHashCode(parent), CalculateReturnStateHashCode
+			(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()
+		{
+			return 1;
+		}
+
+		public override bool IsEmpty()
+		{
+			return false;
+		}
+
+		public override bool HasEmpty()
+		{
+			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/Antlr4.Runtime/Atn/StarBlockStartState.cs b/Antlr4.Runtime/Atn/StarBlockStartState.cs
new file mode 100644
index 000000000..2f6237257
--- /dev/null
+++ b/Antlr4.Runtime/Atn/StarBlockStartState.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 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 int GetStateType()
+		{
+			return StarBlockStart;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/StarLoopEntryState.cs b/Antlr4.Runtime/Atn/StarLoopEntryState.cs
new file mode 100644
index 000000000..dbc7f443b
--- /dev/null
+++ b/Antlr4.Runtime/Atn/StarLoopEntryState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public sealed class StarLoopEntryState : DecisionState
+	{
+		public StarLoopbackState loopBackState;
+
+		public override int GetStateType()
+		{
+			return StarLoopEntry;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/StarLoopbackState.cs b/Antlr4.Runtime/Atn/StarLoopbackState.cs
new file mode 100644
index 000000000..b116b4a35
--- /dev/null
+++ b/Antlr4.Runtime/Atn/StarLoopbackState.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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public sealed class StarLoopbackState : ATNState
+	{
+		public StarLoopEntryState GetLoopEntryState()
+		{
+			return (StarLoopEntryState)Transition(0).target;
+		}
+
+		public override int GetStateType()
+		{
+			return StarLoopBack;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/TokensStartState.cs b/Antlr4.Runtime/Atn/TokensStartState.cs
new file mode 100644
index 000000000..5b03ae01b
--- /dev/null
+++ b/Antlr4.Runtime/Atn/TokensStartState.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 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 int GetStateType()
+		{
+			return TokenStart;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Atn/Transition.cs b/Antlr4.Runtime/Atn/Transition.cs
new file mode 100644
index 000000000..84f2da870
--- /dev/null
+++ b/Antlr4.Runtime/Atn/Transition.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 System.Collections.Generic;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using 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/>
+	/// 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.
+	/// </remarks>
+	public abstract class Transition
+	{
+		public const int Epsilon = 1;
+
+		public const int Range = 2;
+
+		public const int Rule = 3;
+
+		public const int Predicate = 4;
+
+		public const int Atom = 5;
+
+		public const int Action = 6;
+
+		public const int Set = 7;
+
+		public const int NotSet = 8;
+
+		public const int Wildcard = 9;
+
+		public const int Precedence = 10;
+
+		public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList
+			(Arrays.AsList("INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION"
+			, "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"));
+
+		private sealed class _Dictionary_86 : Dictionary<Type, int>
+		{
+			public _Dictionary_86()
+			{
+				{
+					// constants for serialization
+					// e.g., {isType(input.LT(1))}?
+					// ~(A|B) or ~atom, wildcard, which convert to next 2
+					this.Put(typeof(EpsilonTransition), Antlr4.Runtime.Atn.Transition.Epsilon);
+					this.Put(typeof(RangeTransition), Antlr4.Runtime.Atn.Transition.Range);
+					this.Put(typeof(RuleTransition), Antlr4.Runtime.Atn.Transition.Rule);
+					this.Put(typeof(PredicateTransition), Antlr4.Runtime.Atn.Transition.Predicate);
+					this.Put(typeof(AtomTransition), Antlr4.Runtime.Atn.Transition.Atom);
+					this.Put(typeof(ActionTransition), Antlr4.Runtime.Atn.Transition.Action);
+					this.Put(typeof(SetTransition), Antlr4.Runtime.Atn.Transition.Set);
+					this.Put(typeof(NotSetTransition), Antlr4.Runtime.Atn.Transition.NotSet);
+					this.Put(typeof(WildcardTransition), Antlr4.Runtime.Atn.Transition.Wildcard);
+					this.Put(typeof(PrecedencePredicateTransition), Antlr4.Runtime.Atn.Transition.Precedence
+						);
+				}
+			}
+		}
+
+		public static readonly IDictionary<Type, int> serializationTypes = Sharpen.Collections
+			.UnmodifiableMap(new _Dictionary_86());
+
+		/// <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 int GetSerializationType();
+
+		/// <summary>Are we epsilon, action, sempred?</summary>
+		public virtual bool IsEpsilon()
+		{
+			return false;
+		}
+
+		[Nullable]
+		public virtual IntervalSet Label()
+		{
+			return null;
+		}
+
+		public abstract bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol);
+	}
+}
diff --git a/Antlr4.Runtime/Atn/WildcardTransition.cs b/Antlr4.Runtime/Atn/WildcardTransition.cs
new file mode 100644
index 000000000..34247c8d6
--- /dev/null
+++ b/Antlr4.Runtime/Atn/WildcardTransition.cs
@@ -0,0 +1,58 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Atn
+{
+	public sealed class WildcardTransition : Transition
+	{
+		protected internal WildcardTransition(ATNState target) : base(target)
+		{
+		}
+
+		public override int GetSerializationType()
+		{
+			return Wildcard;
+		}
+
+		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+		{
+			return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
+		}
+
+		[NotNull]
+		public override string ToString()
+		{
+			return ".";
+		}
+	}
+}
diff --git a/Antlr4.Runtime/BailErrorStrategy.cs b/Antlr4.Runtime/BailErrorStrategy.cs
new file mode 100644
index 000000000..c492e577b
--- /dev/null
+++ b/Antlr4.Runtime/BailErrorStrategy.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;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>Bail out of parser at first syntax error.</summary>
+	/// <remarks>
+	/// Bail out of parser at first syntax error. Do this to use it:
+	/// <p/>
+	/// <code>myparser.setErrorHandler(new BailErrorStrategy<Token>());</code>
+	/// </remarks>
+	public class BailErrorStrategy : DefaultErrorStrategy
+	{
+		/// <summary>
+		/// Instead of recovering from exception
+		/// <code>e</code>
+		/// , re-throw it wrapped
+		/// in a
+		/// <see cref="ParseCanceledException">ParseCanceledException</see>
+		/// so it is not caught by the
+		/// rule function catches.  Use
+		/// <see cref="System.Exception.InnerException()">System.Exception.InnerException()</see>
+		/// to get the
+		/// original
+		/// <see cref="RecognitionException">RecognitionException</see>
+		/// .
+		/// </summary>
+		public override void Recover(Parser recognizer, RecognitionException e)
+		{
+			for (ParserRuleContext context = recognizer.GetContext(); context != null; context
+				 = ((ParserRuleContext)context.GetParent()))
+			{
+				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"></exception>
+		public override Token RecoverInline(Parser recognizer)
+		{
+			InputMismatchException e = new InputMismatchException(recognizer);
+			for (ParserRuleContext context = recognizer.GetContext(); context != null; context
+				 = ((ParserRuleContext)context.GetParent()))
+			{
+				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/Antlr4.Runtime/BaseErrorListener.cs b/Antlr4.Runtime/BaseErrorListener.cs
new file mode 100644
index 000000000..bfb24600a
--- /dev/null
+++ b/Antlr4.Runtime/BaseErrorListener.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;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <author>Sam Harwell</author>
+	public class BaseErrorListener : ParserErrorListener
+	{
+		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
+			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
+			Token
+		{
+		}
+
+		public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
+			 stopIndex, BitSet ambigAlts, ATNConfigSet configs)
+		{
+		}
+
+		public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
+			, int stopIndex, SimulatorState initialState)
+		{
+		}
+
+		public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
+			, int stopIndex, SimulatorState acceptState)
+		{
+		}
+	}
+}
diff --git a/Antlr4.Runtime/BufferedTokenStream.cs b/Antlr4.Runtime/BufferedTokenStream.cs
new file mode 100644
index 000000000..b80517723
--- /dev/null
+++ b/Antlr4.Runtime/BufferedTokenStream.cs
@@ -0,0 +1,661 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// Buffer all input tokens but do on-demand fetching of new tokens from
+	/// lexer.
+	/// </summary>
+	/// <remarks>
+	/// 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></code>
+	/// &lt;names:
+	/// hi, <it>}&gt;} has to parse names
+	/// as part of an expression but
+	/// <code>"hi, <it>"</code>
+	/// as a nested template.
+	/// 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.
+	/// (
+	/// <see cref="UnbufferedTokenStream">UnbufferedTokenStream</see>
+	/// is the same way.)  Use
+	/// <see cref="CommonTokenStream">CommonTokenStream</see>
+	/// .
+	/// This is not a subclass of
+	/// <code>UnbufferedTokenStream</code>
+	/// because I don't want
+	/// to confuse small moving window of tokens it uses for the full buffer.
+	/// </remarks>
+	public class BufferedTokenStream : TokenStream
+	{
+		[NotNull]
+		protected internal TokenSource tokenSource;
+
+		/// <summary>
+		/// Record every single token pulled from the source so we can reproduce
+		/// chunks of it later.
+		/// </summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		protected internal IList<Token> tokens = new AList<Token>(100);
+
+		/// <summary>
+		/// The index into the tokens list of the current token (next token
+		/// to consume).
+		/// </summary>
+		/// <remarks>
+		/// The index into the tokens list of the current token (next token
+		/// to consume).
+		/// <code>tokens[p]</code>
+		/// should be
+		/// <code>LT(1)</code>
+		/// .
+		/// <code>p==-1</code>
+		/// indicates need
+		/// to initialize with first token.  The ctor doesn't get a token.
+		/// First call to
+		/// <code>LT(1)</code>
+		/// or whatever gets the first token and sets
+		/// <code>p=0;</code>
+		/// .
+		/// </remarks>
+		protected internal int p = -1;
+
+		/// <summary>
+		/// Set to
+		/// <code>true</code>
+		/// when the EOF token is fetched. Do not continue fetching
+		/// tokens after that point, or multiple EOF tokens could end up in the
+		/// <see cref="tokens">tokens</see>
+		/// array.
+		/// </summary>
+		/// <seealso cref="Fetch(int)">Fetch(int)</seealso>
+		protected internal bool fetchedEOF;
+
+		public BufferedTokenStream(TokenSource tokenSource)
+		{
+			if (tokenSource == null)
+			{
+				throw new ArgumentNullException("tokenSource cannot be null");
+			}
+			this.tokenSource = tokenSource;
+		}
+
+		public virtual TokenSource GetTokenSource()
+		{
+			return tokenSource;
+		}
+
+		public virtual int Index()
+		{
+			return p;
+		}
+
+		//	public int range() { return range; }
+		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()
+		{
+			return tokens.Count;
+		}
+
+		public virtual void Consume()
+		{
+			if (La(1) == Eof)
+			{
+				throw new InvalidOperationException("cannot consume EOF");
+			}
+			if (Sync(p + 1))
+			{
+				p = AdjustSeekIndex(p + 1);
+			}
+		}
+
+		/// <summary>
+		/// Make sure index
+		/// <code>i</code>
+		/// in tokens has a token.
+		/// </summary>
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// if a token is located at index
+		/// <code>i</code>
+		/// , otherwise
+		/// <code>false</code>
+		/// .
+		/// </returns>
+		/// <seealso cref="Get(int)">Get(int)</seealso>
+		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
+		/// <code>n</code>
+		/// 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++)
+			{
+				Token t = tokenSource.NextToken();
+				if (t is WritableToken)
+				{
+					((WritableToken)t).SetTokenIndex(tokens.Count);
+				}
+				tokens.AddItem(t);
+				if (t.GetType() == Token.Eof)
+				{
+					fetchedEOF = true;
+					return i + 1;
+				}
+			}
+			return n;
+		}
+
+		public virtual Token Get(int i)
+		{
+			if (i < 0 || i >= tokens.Count)
+			{
+				throw new IndexOutOfRangeException("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<Token> Get(int start, int stop)
+		{
+			if (start < 0 || stop < 0)
+			{
+				return null;
+			}
+			LazyInit();
+			IList<Token> subset = new AList<Token>();
+			if (stop >= tokens.Count)
+			{
+				stop = tokens.Count - 1;
+			}
+			for (int i = start; i <= stop; i++)
+			{
+				Token t = tokens[i];
+				if (t.GetType() == Token.Eof)
+				{
+					break;
+				}
+				subset.AddItem(t);
+			}
+			return subset;
+		}
+
+		public virtual int La(int i)
+		{
+			return Lt(i).GetType();
+		}
+
+		protected internal virtual Token Lb(int k)
+		{
+			if ((p - k) < 0)
+			{
+				return null;
+			}
+			return tokens[p - k];
+		}
+
+		public virtual Token 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
+		/// <code>i</code>
+		/// . If an
+		/// exception is thrown in this method, the current stream index should not be
+		/// changed.
+		/// <p/>
+		/// For example,
+		/// <see cref="CommonTokenStream">CommonTokenStream</see>
+		/// overrides this method to ensure that
+		/// the seek target is always an on-channel token.
+		/// </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(TokenSource tokenSource)
+		{
+			this.tokenSource = tokenSource;
+			tokens.Clear();
+			p = -1;
+		}
+
+		public virtual IList<Token> GetTokens()
+		{
+			return tokens;
+		}
+
+		public virtual IList<Token> GetTokens(int start, int stop)
+		{
+			return GetTokens(start, stop, null);
+		}
+
+		/// <summary>
+		/// Given a start and stop index, return a
+		/// <code>List</code>
+		/// of all tokens in
+		/// the token type
+		/// <code>BitSet</code>
+		/// .  Return
+		/// <code>null</code>
+		/// if no tokens were found.  This
+		/// method looks at both on and off channel tokens.
+		/// </summary>
+		public virtual IList<Token> GetTokens(int start, int stop, BitSet types)
+		{
+			LazyInit();
+			if (start < 0 || stop >= tokens.Count || stop < 0 || start >= tokens.Count)
+			{
+				throw new IndexOutOfRangeException("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<Token> filteredTokens = new AList<Token>();
+			for (int i = start; i <= stop; i++)
+			{
+				Token t = tokens[i];
+				if (types == null || types.Get(t.GetType()))
+				{
+					filteredTokens.AddItem(t);
+				}
+			}
+			if (filteredTokens.IsEmpty())
+			{
+				filteredTokens = null;
+			}
+			return filteredTokens;
+		}
+
+		public virtual IList<Token> 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
+		/// <code>i</code>
+		/// if
+		/// <code>tokens[i]</code>
+		/// is on channel.  Return
+		/// <code>-1</code>
+		/// if there are no tokens
+		/// on channel between
+		/// <code>i</code>
+		/// and EOF.
+		/// </remarks>
+		protected internal virtual int NextTokenOnChannel(int i, int channel)
+		{
+			Sync(i);
+			Token token = tokens[i];
+			if (i >= Size())
+			{
+				return -1;
+			}
+			while (token.GetChannel() != channel)
+			{
+				if (token.GetType() == Token.Eof)
+				{
+					return -1;
+				}
+				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
+		/// <code>i</code>
+		/// if
+		/// <code>tokens[i]</code>
+		/// is on channel. Return
+		/// <code>-1</code>
+		/// if there are no tokens
+		/// on channel between
+		/// <code>i</code>
+		/// and
+		/// <code>0</code>
+		/// .
+		/// </remarks>
+		protected internal virtual int PreviousTokenOnChannel(int i, int channel)
+		{
+			while (i >= 0 && tokens[i].GetChannel() != channel)
+			{
+				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">Lexer.DefaultTokenChannel</see>
+		/// or
+		/// EOF. If
+		/// <code>channel</code>
+		/// is
+		/// <code>-1</code>
+		/// , find any non default channel token.
+		/// </summary>
+		public virtual IList<Token> GetHiddenTokensToRight(int tokenIndex, int channel)
+		{
+			LazyInit();
+			if (tokenIndex < 0 || tokenIndex >= tokens.Count)
+			{
+				throw new IndexOutOfRangeException(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">Lexer.DefaultTokenChannel</see>
+		/// or EOF.
+		/// </summary>
+		public virtual IList<Token> 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">Lexer.DefaultTokenChannel</see>
+		/// .
+		/// If
+		/// <code>channel</code>
+		/// is
+		/// <code>-1</code>
+		/// , find any non default channel token.
+		/// </summary>
+		public virtual IList<Token> GetHiddenTokensToLeft(int tokenIndex, int channel)
+		{
+			LazyInit();
+			if (tokenIndex < 0 || tokenIndex >= tokens.Count)
+			{
+				throw new IndexOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count - 1
+					));
+			}
+			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">Lexer.DefaultTokenChannel</see>
+		/// .
+		/// </summary>
+		public virtual IList<Token> GetHiddenTokensToLeft(int tokenIndex)
+		{
+			return GetHiddenTokensToLeft(tokenIndex, -1);
+		}
+
+		protected internal virtual IList<Token> FilterForChannel(int from, int to, int channel
+			)
+		{
+			IList<Token> hidden = new AList<Token>();
+			for (int i = from; i <= to; i++)
+			{
+				Token t = tokens[i];
+				if (channel == -1)
+				{
+					if (t.GetChannel() != Lexer.DefaultTokenChannel)
+					{
+						hidden.AddItem(t);
+					}
+				}
+				else
+				{
+					if (t.GetChannel() == channel)
+					{
+						hidden.AddItem(t);
+					}
+				}
+			}
+			if (hidden.IsEmpty())
+			{
+				return null;
+			}
+			return hidden;
+		}
+
+		public virtual string GetSourceName()
+		{
+			return tokenSource.GetSourceName();
+		}
+
+		/// <summary>Get the text of all tokens in this buffer.</summary>
+		/// <remarks>Get the text of all tokens in this buffer.</remarks>
+		[NotNull]
+		public virtual string GetText()
+		{
+			Fill();
+			return GetText(Interval.Of(0, Size() - 1));
+		}
+
+		[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++)
+			{
+				Token t = tokens[i];
+				if (t.GetType() == Token.Eof)
+				{
+					break;
+				}
+				buf.Append(t.GetText());
+			}
+			return buf.ToString();
+		}
+
+		[NotNull]
+		public virtual string GetText(RuleContext ctx)
+		{
+			return GetText(ctx.GetSourceInterval());
+		}
+
+		[NotNull]
+		public virtual string GetText(Token start, Token stop)
+		{
+			if (start != null && stop != null)
+			{
+				return GetText(Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex()));
+			}
+			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/Antlr4.Runtime/CharStream.cs b/Antlr4.Runtime/CharStream.cs
new file mode 100644
index 000000000..7f900c99e
--- /dev/null
+++ b/Antlr4.Runtime/CharStream.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.
+ */
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using 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 abstract class CharStream : IntStream
+	{
+		/// <summary>
+		/// The minimum allowed value for a character in a
+		/// <code>CharStream</code>
+		/// .
+		/// </summary>
+		public const int MinChar = char.MinValue;
+
+		/// <summary>
+		/// The maximum allowed value for a character in a
+		/// <code>CharStream</code>
+		/// .
+		/// <p/>
+		/// This value is
+		/// <code>Character.MAX_VALUE - 1</code>
+		/// , which reserves the value
+		/// <code>Character.MAX_VALUE</code>
+		/// for special use within an implementing class.
+		/// For some implementations, the data buffers required for supporting the
+		/// marked ranges of
+		/// <see cref="IntStream">IntStream</see>
+		/// are stored as
+		/// <code>char[]</code>
+		/// instead
+		/// of
+		/// <code>int[]</code>
+		/// , with
+		/// <code>Character.MAX_VALUE</code>
+		/// being used instead of
+		/// <code>-1</code>
+		/// to mark the end of the stream internally.
+		/// </summary>
+		public const int MaxChar = char.MaxValue - 1;
+
+		/// <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
+		/// <code>interval</code>
+		/// lies entirely within a marked range. For more
+		/// information about marked ranges, see
+		/// <see cref="IntStream.Mark()">IntStream.Mark()</see>
+		/// .
+		/// </remarks>
+		/// <param name="interval">an interval within the stream</param>
+		/// <returns>the text of the specified interval</returns>
+		/// <exception cref="System.ArgumentNullException">
+		/// if
+		/// <code>interval</code>
+		/// is
+		/// <code>null</code>
+		/// </exception>
+		/// <exception cref="System.ArgumentException">
+		/// if
+		/// <code>interval.a &lt; 0</code>
+		/// , or if
+		/// <code>interval.b &lt; interval.a - 1</code>
+		/// , or if
+		/// <code>interval.b</code>
+		/// 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>
+		[NotNull]
+		public abstract string GetText(Interval interval);
+	}
+}
diff --git a/Antlr4.Runtime/CommonToken.cs b/Antlr4.Runtime/CommonToken.cs
new file mode 100644
index 000000000..a2d6df1ea
--- /dev/null
+++ b/Antlr4.Runtime/CommonToken.cs
@@ -0,0 +1,255 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	[System.Serializable]
+	public class CommonToken : WritableToken
+	{
+		private const long serialVersionUID = -6708843461296520577L;
+
+		protected internal int type;
+
+		protected internal int line;
+
+		protected internal int charPositionInLine = -1;
+
+		protected internal int channel = DefaultChannel;
+
+		protected internal Tuple<TokenSource, CharStream> source;
+
+		/// <summary>We need to be able to change the text once in a while.</summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		protected internal string text;
+
+		/// <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index
+		/// 	</summary>
+		protected internal int index = -1;
+
+		/// <summary>The char position into the input buffer where this token starts</summary>
+		protected internal int start;
+
+		/// <summary>The char position into the input buffer where this token stops</summary>
+		protected internal int stop;
+
+		public CommonToken(int type)
+		{
+			// set to invalid position
+			// TODO: can store these in map in token stream rather than as field here
+			this.type = type;
+		}
+
+		public CommonToken(Tuple<TokenSource, CharStream> 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.GetItem1() != null)
+			{
+				this.line = source.GetItem1().GetLine();
+				this.charPositionInLine = source.GetItem1().GetCharPositionInLine();
+			}
+		}
+
+		public CommonToken(int type, string text)
+		{
+			this.type = type;
+			this.channel = DefaultChannel;
+			this.text = text;
+		}
+
+		public CommonToken(Token oldToken)
+		{
+			text = oldToken.GetText();
+			type = oldToken.GetType();
+			line = oldToken.GetLine();
+			index = oldToken.GetTokenIndex();
+			charPositionInLine = oldToken.GetCharPositionInLine();
+			channel = oldToken.GetChannel();
+			start = oldToken.GetStartIndex();
+			stop = oldToken.GetStopIndex();
+			if (oldToken is Antlr4.Runtime.CommonToken)
+			{
+				source = ((Antlr4.Runtime.CommonToken)oldToken).source;
+			}
+			else
+			{
+				source = Tuple.Create(oldToken.GetTokenSource(), oldToken.GetInputStream());
+			}
+		}
+
+		public virtual int GetType()
+		{
+			return type;
+		}
+
+		public virtual void SetLine(int line)
+		{
+			this.line = line;
+		}
+
+		public virtual string GetText()
+		{
+			if (text != null)
+			{
+				return text;
+			}
+			CharStream input = GetInputStream();
+			if (input == null)
+			{
+				return null;
+			}
+			int n = input.Size();
+			if (start < n && stop < n)
+			{
+				return input.GetText(Interval.Of(start, stop));
+			}
+			else
+			{
+				return "<EOF>";
+			}
+		}
+
+		/// <summary>Override the text for this token.</summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		public virtual void SetText(string text)
+		{
+			this.text = text;
+		}
+
+		public virtual int GetLine()
+		{
+			return line;
+		}
+
+		public virtual int GetCharPositionInLine()
+		{
+			return charPositionInLine;
+		}
+
+		public virtual void SetCharPositionInLine(int charPositionInLine)
+		{
+			this.charPositionInLine = charPositionInLine;
+		}
+
+		public virtual int GetChannel()
+		{
+			return channel;
+		}
+
+		public virtual void SetChannel(int channel)
+		{
+			this.channel = channel;
+		}
+
+		public virtual void SetType(int type)
+		{
+			this.type = type;
+		}
+
+		public virtual int GetStartIndex()
+		{
+			return start;
+		}
+
+		public virtual void SetStartIndex(int start)
+		{
+			this.start = start;
+		}
+
+		public virtual int GetStopIndex()
+		{
+			return stop;
+		}
+
+		public virtual void SetStopIndex(int stop)
+		{
+			this.stop = stop;
+		}
+
+		public virtual int GetTokenIndex()
+		{
+			return index;
+		}
+
+		public virtual void SetTokenIndex(int index)
+		{
+			this.index = index;
+		}
+
+		public virtual TokenSource GetTokenSource()
+		{
+			return source.GetItem1();
+		}
+
+		public virtual CharStream GetInputStream()
+		{
+			return source.GetItem2();
+		}
+
+		public override string ToString()
+		{
+			string channelStr = string.Empty;
+			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() + "," + start + ":" + stop + "='" + txt + "',<" + type
+				 + ">" + channelStr + "," + line + ":" + GetCharPositionInLine() + "]";
+		}
+	}
+}
diff --git a/Antlr4.Runtime/CommonTokenFactory.cs b/Antlr4.Runtime/CommonTokenFactory.cs
new file mode 100644
index 000000000..d25bfe5c0
--- /dev/null
+++ b/Antlr4.Runtime/CommonTokenFactory.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.
+ */
+using System;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	public class CommonTokenFactory : TokenFactory
+	{
+		public static readonly TokenFactory Default = new Antlr4.Runtime.CommonTokenFactory
+			();
+
+		/// <summary>Copy text for token out of input char stream.</summary>
+		/// <remarks>
+		/// Copy text for token out of input char stream. Useful when input
+		/// stream is unbuffered.
+		/// </remarks>
+		/// <seealso cref="UnbufferedCharStream">UnbufferedCharStream</seealso>
+		protected internal readonly bool copyText;
+
+		/// <summary>
+		/// Create factory and indicate whether or not the factory copy
+		/// text out of the char stream.
+		/// </summary>
+		/// <remarks>
+		/// Create factory and indicate whether or not the factory copy
+		/// text out of the char stream.
+		/// </remarks>
+		public CommonTokenFactory(bool copyText)
+		{
+			this.copyText = copyText;
+		}
+
+		public CommonTokenFactory() : this(false)
+		{
+		}
+
+		public virtual CommonToken Create<_T0>(Tuple<_T0> source, int type, string text, 
+			int channel, int start, int stop, int line, int charPositionInLine) where _T0:TokenSource
+		{
+			CommonToken t = new CommonToken(source, type, channel, start, stop);
+			t.SetLine(line);
+			t.SetCharPositionInLine(charPositionInLine);
+			if (text != null)
+			{
+				t.SetText(text);
+			}
+			else
+			{
+				if (copyText && source.GetItem2() != null)
+				{
+					t.SetText(source.GetItem2().GetText(Interval.Of(start, stop)));
+				}
+			}
+			return t;
+		}
+
+		public virtual CommonToken Create(int type, string text)
+		{
+			return new CommonToken(type, text);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/CommonTokenStream.cs b/Antlr4.Runtime/CommonTokenStream.cs
new file mode 100644
index 000000000..215d09bb0
--- /dev/null
+++ b/Antlr4.Runtime/CommonTokenStream.cs
@@ -0,0 +1,156 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// 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).
+	/// </summary>
+	/// <remarks>
+	/// 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).
+	/// 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.
+	/// The only difference between this stream and
+	/// <see cref="BufferedTokenStream">BufferedTokenStream</see>
+	/// 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</code>
+	/// instead of calling
+	/// <code>skip()</code>
+	/// in lexer rules.)
+	/// </remarks>
+	/// <seealso cref="UnbufferedTokenStream">UnbufferedTokenStream</seealso>
+	/// <seealso cref="BufferedTokenStream">BufferedTokenStream</seealso>
+	public class CommonTokenStream : BufferedTokenStream
+	{
+		/// <summary>Skip tokens on any channel but this one; this is how we skip whitespace...
+		/// 	</summary>
+		/// <remarks>Skip tokens on any channel but this one; this is how we skip whitespace...
+		/// 	</remarks>
+		protected internal int channel = Token.DefaultChannel;
+
+		public CommonTokenStream(TokenSource tokenSource) : base(tokenSource)
+		{
+		}
+
+		public CommonTokenStream(TokenSource tokenSource, int channel) : this(tokenSource
+			)
+		{
+			this.channel = channel;
+		}
+
+		protected internal override int AdjustSeekIndex(int i)
+		{
+			return NextTokenOnChannel(i, channel);
+		}
+
+		protected internal override Token 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 Token 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++)
+			{
+				Token t = tokens[i];
+				if (t.GetChannel() == channel)
+				{
+					n++;
+				}
+				if (t.GetType() == Token.Eof)
+				{
+					break;
+				}
+			}
+			return n;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/ConsoleErrorListener.cs b/Antlr4.Runtime/ConsoleErrorListener.cs
new file mode 100644
index 000000000..e37a75e4c
--- /dev/null
+++ b/Antlr4.Runtime/ConsoleErrorListener.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;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <author>Sam Harwell</author>
+	public class ConsoleErrorListener : ANTLRErrorListener<object>
+	{
+		public static readonly ConsoleErrorListener Instance = new ConsoleErrorListener();
+
+		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
+			, int line, int charPositionInLine, string msg, RecognitionException e)
+		{
+			System.Console.Error.WriteLine("line " + line + ":" + charPositionInLine + " " + 
+				msg);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/DefaultErrorStrategy.cs b/Antlr4.Runtime/DefaultErrorStrategy.cs
new file mode 100644
index 000000000..219a4e9be
--- /dev/null
+++ b/Antlr4.Runtime/DefaultErrorStrategy.cs
@@ -0,0 +1,549 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// This is the default error handling mechanism for ANTLR parsers
+	/// and tree parsers.
+	/// </summary>
+	/// <remarks>
+	/// This is the default error handling mechanism for ANTLR parsers
+	/// and tree parsers.
+	/// </remarks>
+	public class DefaultErrorStrategy : ANTLRErrorStrategy
+	{
+		/// <summary>
+		/// This is true after we see an error and before having successfully
+		/// matched a token.
+		/// </summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		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;
+
+		public virtual void BeginErrorCondition(Parser recognizer)
+		{
+			errorRecoveryMode = true;
+		}
+
+		public virtual bool InErrorRecoveryMode(Parser recognizer)
+		{
+			return errorRecoveryMode;
+		}
+
+		public virtual void EndErrorCondition(Parser recognizer)
+		{
+			errorRecoveryMode = false;
+			lastErrorStates = null;
+			lastErrorIndex = -1;
+		}
+
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		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 (errorRecoveryMode)
+			{
+				//			System.err.print("[SPURIOUS] ");
+				return;
+			}
+			// don't count spurious errors
+			recognizer._syntaxErrors++;
+			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
+					{
+						System.Console.Error.WriteLine("unknown recognition error type: " + e.GetType().FullName
+							);
+						NotifyErrorListeners(recognizer, e.Message, e);
+					}
+				}
+			}
+		}
+
+		protected internal virtual void NotifyErrorListeners(Parser recognizer, string message
+			, RecognitionException e)
+		{
+			if (recognizer != null)
+			{
+				recognizer.NotifyErrorListeners(e.GetOffendingToken(), message, e);
+			}
+		}
+
+		/// <summary>Recover from NoViableAlt errors.</summary>
+		/// <remarks>
+		/// Recover from NoViableAlt errors. Also there could be a mismatched
+		/// token that the match() routine could not recover from.
+		/// </remarks>
+		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 == ((TokenStream)recognizer.GetInputStream()).Index() && lastErrorStates
+				 != null && lastErrorStates.Contains(recognizer.GetState()))
+			{
+				// 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 = ((TokenStream)recognizer.GetInputStream()).Index();
+			if (lastErrorStates == null)
+			{
+				lastErrorStates = new IntervalSet();
+			}
+			lastErrorStates.Add(recognizer.GetState());
+			IntervalSet followSet = GetErrorRecoverySet(recognizer);
+			ConsumeUntil(recognizer, followSet);
+		}
+
+		/// <summary>
+		/// Make sure that the current lookahead symbol is consistent with
+		/// what were expecting at this point in the ATN.
+		/// </summary>
+		/// <remarks>
+		/// Make sure that the current lookahead symbol is consistent with
+		/// what were expecting at this point in the ATN.
+		/// At the start of a sub rule upon error, 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.
+		/// If the sub rule is optional, ()? or ()* or optional alternative,
+		/// then the expected set includes what follows the subrule.
+		/// 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.
+		/// </remarks>
+		public virtual void Sync(Parser recognizer)
+		{
+			ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
+			//		System.err.println("sync @ "+s.stateNumber+"="+s.getClass().getSimpleName());
+			// If already recovering, don't try to sync
+			if (errorRecoveryMode)
+			{
+				return;
+			}
+			TokenStream tokens = ((TokenStream)recognizer.GetInputStream());
+			int la = tokens.La(1);
+			// try cheaper subset first; might get lucky. seems to shave a wee bit off
+			if (recognizer.GetATN().NextTokens(s).Contains(la) || la == Token.Eof)
+			{
+				return;
+			}
+			// Return but don't end recovery. only do that upon valid token match
+			if (recognizer.IsExpectedToken(la))
+			{
+				return;
+			}
+			switch (s.GetStateType())
+			{
+				case ATNState.BlockStart:
+				case ATNState.StarBlockStart:
+				case ATNState.PlusBlockStart:
+				case ATNState.StarLoopEntry:
+				{
+					// report error and recover if possible
+					if (SingleTokenDeletion(recognizer) != null)
+					{
+						return;
+					}
+					throw new InputMismatchException(recognizer);
+				}
+
+				case ATNState.PlusLoopBack:
+				case ATNState.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;
+					break;
+				}
+			}
+		}
+
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		public virtual void ReportNoViableAlternative(Parser recognizer, NoViableAltException
+			 e)
+		{
+			TokenStream tokens = ((TokenStream)recognizer.GetInputStream());
+			string input;
+			if (tokens != null)
+			{
+				if (e.GetStartToken().GetType() == Token.Eof)
+				{
+					input = "<EOF>";
+				}
+				else
+				{
+					input = tokens.GetText(e.GetStartToken(), e.GetOffendingToken());
+				}
+			}
+			else
+			{
+				input = "<unknown input>";
+			}
+			string msg = "no viable alternative at input " + EscapeWSAndQuote(input);
+			NotifyErrorListeners(recognizer, msg, e);
+		}
+
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		public virtual void ReportInputMismatch(Parser recognizer, InputMismatchException
+			 e)
+		{
+			string msg = "mismatched input " + GetTokenErrorDisplay(e.GetOffendingToken()) + 
+				" expecting " + e.GetExpectedTokens().ToString(recognizer.GetTokenNames());
+			NotifyErrorListeners(recognizer, msg, e);
+		}
+
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		public virtual void ReportFailedPredicate(Parser recognizer, FailedPredicateException
+			 e)
+		{
+			string ruleName = recognizer.GetRuleNames()[recognizer._ctx.GetRuleIndex()];
+			string msg = "rule " + ruleName + " " + e.Message;
+			NotifyErrorListeners(recognizer, msg, e);
+		}
+
+		public virtual void ReportUnwantedToken(Parser recognizer)
+		{
+			if (errorRecoveryMode)
+			{
+				return;
+			}
+			recognizer._syntaxErrors++;
+			BeginErrorCondition(recognizer);
+			Token t = recognizer.GetCurrentToken();
+			string tokenName = GetTokenErrorDisplay(t);
+			IntervalSet expecting = GetExpectedTokens(recognizer);
+			string msg = "extraneous input " + tokenName + " expecting " + expecting.ToString
+				(recognizer.GetTokenNames());
+			recognizer.NotifyErrorListeners(t, msg, null);
+		}
+
+		public virtual void ReportMissingToken(Parser recognizer)
+		{
+			if (errorRecoveryMode)
+			{
+				return;
+			}
+			recognizer._syntaxErrors++;
+			BeginErrorCondition(recognizer);
+			Token t = recognizer.GetCurrentToken();
+			IntervalSet expecting = GetExpectedTokens(recognizer);
+			string msg = "missing " + expecting.ToString(recognizer.GetTokenNames()) + " at "
+				 + GetTokenErrorDisplay(t);
+			recognizer.NotifyErrorListeners(t, msg, null);
+		}
+
+		/// <summary>Attempt to recover from a single missing or extra token.</summary>
+		/// <remarks>
+		/// Attempt to recover from a single missing or extra token.
+		/// EXTRA TOKEN
+		/// LA(1) is not what we are looking for.  If LA(2) has the right token,
+		/// however, then assume LA(1) is some extra spurious token.  Delete it
+		/// and LA(2) as if we were doing a normal match(), which advances the
+		/// input.
+		/// MISSING TOKEN
+		/// If current token is consistent with what could come after
+		/// ttype then it is ok to "insert" the missing token, else throw
+		/// exception For example, Input "i=(3;" is clearly missing the
+		/// ')'.  When the parser returns from the nested call to expr, it
+		/// will have call chain:
+		/// stat -&gt; expr -&gt; atom
+		/// and it will be trying to match the ')' at this point in the
+		/// derivation:
+		/// =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+		/// ^
+		/// match() will see that ';' doesn't match ')' and report a
+		/// mismatched token error.  To recover, it sees that LA(1)==';'
+		/// is in the set of tokens that can follow the ')' token
+		/// reference in rule atom.  It can assume that you forgot the ')'.
+		/// </remarks>
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		public virtual Token RecoverInline(Parser recognizer)
+		{
+			// SINGLE TOKEN DELETION
+			Token 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);
+		}
+
+		// if next token is what we are looking for then "delete" this token
+		public virtual bool SingleTokenInsertion(Parser recognizer)
+		{
+			int currentSymbolType = ((TokenStream)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
+			// is free to conjure up and insert the missing token
+			ATNState currentState = recognizer.GetInterpreter().atn.states[recognizer.GetState
+				()];
+			ATNState next = currentState.Transition(0).target;
+			ATN atn = recognizer.GetInterpreter().atn;
+			IntervalSet expectingAtLL2 = atn.NextTokens(next, PredictionContext.FromRuleContext
+				(atn, recognizer._ctx));
+			//		System.out.println("LT(2) set="+expectingAtLL2.toString(recognizer.getTokenNames()));
+			if (expectingAtLL2.Contains(currentSymbolType))
+			{
+				ReportMissingToken(recognizer);
+				return true;
+			}
+			return false;
+		}
+
+		public virtual Token SingleTokenDeletion(Parser recognizer)
+		{
+			int nextTokenType = ((TokenStream)recognizer.GetInputStream()).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
+				Token matchedSymbol = recognizer.GetCurrentToken();
+				EndErrorCondition(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>
+		protected internal virtual 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] + ">";
+			}
+			Token current = currentSymbol;
+			Token lookback = ((TokenStream)recognizer.GetInputStream()).Lt(-1);
+			if (current.GetType() == Token.Eof && lookback != null)
+			{
+				current = lookback;
+			}
+			return ConstructToken(((TokenStream)recognizer.GetInputStream()).GetTokenSource()
+				, expectedTokenType, tokenText, current);
+		}
+
+		protected internal virtual Token ConstructToken(TokenSource tokenSource, int expectedTokenType
+			, string tokenText, Token current)
+		{
+			TokenFactory factory = tokenSource.GetTokenFactory();
+			return factory.Create(Tuple.Create(tokenSource, current.GetTokenSource().GetInputStream
+				()), expectedTokenType, tokenText, Token.DefaultChannel, -1, -1, current.GetLine
+				(), current.GetCharPositionInLine());
+		}
+
+		public 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>
+		public virtual string GetTokenErrorDisplay(Token t)
+		{
+			if (t == null)
+			{
+				return "<no token>";
+			}
+			string s = GetSymbolText(t);
+			if (s == null)
+			{
+				if (GetSymbolType(t) == Token.Eof)
+				{
+					s = "<EOF>";
+				}
+				else
+				{
+					s = "<" + GetSymbolType(t) + ">";
+				}
+			}
+			return EscapeWSAndQuote(s);
+		}
+
+		protected internal virtual string GetSymbolText(Token symbol)
+		{
+			return symbol.GetText();
+		}
+
+		protected internal virtual int GetSymbolType(Token symbol)
+		{
+			return symbol.GetType();
+		}
+
+		protected internal virtual string EscapeWSAndQuote(string s)
+		{
+			//		if ( s==null ) return s;
+			s = s.ReplaceAll("\n", "\\\\n");
+			s = s.ReplaceAll("\r", "\\\\r");
+			s = s.ReplaceAll("\t", "\\\\t");
+			return "'" + s + "'";
+		}
+
+		protected internal virtual IntervalSet GetErrorRecoverySet(Parser recognizer)
+		{
+			ATN atn = recognizer.GetInterpreter().atn;
+			RuleContext ctx = recognizer._ctx;
+			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(Token.Epsilon);
+			//		System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames()));
+			return recoverSet;
+		}
+
+		/// <summary>Consume tokens until one matches the given token set</summary>
+		public virtual void ConsumeUntil(Parser recognizer, IntervalSet set)
+		{
+			//		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
+			int ttype = ((TokenStream)recognizer.GetInputStream()).La(1);
+			while (ttype != Token.Eof && !set.Contains(ttype))
+			{
+				//System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
+				//			recognizer.getInputStream().consume();
+				recognizer.Consume();
+				ttype = ((TokenStream)recognizer.GetInputStream()).La(1);
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Dependents.cs b/Antlr4.Runtime/Dependents.cs
new file mode 100644
index 000000000..84957329e
--- /dev/null
+++ b/Antlr4.Runtime/Dependents.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;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <author>Sam Harwell</author>
+	public enum Dependents
+	{
+		Self,
+		Parents,
+		Children,
+		Ancestors,
+		Descendants,
+		Siblings,
+		PreceedingSiblings,
+		FollowingSiblings,
+		Preceeding,
+		Following
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs b/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
new file mode 100644
index 000000000..c886d56dd
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/AbstractEdgeMap.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;
+using System.Collections.Generic;
+using Antlr4.Runtime.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+	/// <author>Sam Harwell</author>
+	public abstract class AbstractEdgeMap<T> : EdgeMap<T>
+	{
+		protected internal readonly int minIndex;
+
+		protected internal readonly int maxIndex;
+
+		public 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);
+
+		public virtual Antlr4.Runtime.Dfa.AbstractEdgeMap<T> PutAll<_T0>(EdgeMap<_T0> m) where 
+			_T0:T
+		{
+			Antlr4.Runtime.Dfa.AbstractEdgeMap<T> result = this;
+			foreach (KeyValuePair<int, T> entry in m.EntrySet())
+			{
+				result = result.Put(entry.Key, entry.Value);
+			}
+			return result;
+		}
+
+		public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Clear();
+
+		public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Remove(int key);
+
+		protected internal abstract class AbstractEntrySet : AbstractSet<KeyValuePair<int
+			, T>>
+		{
+			public override bool Contains(object o)
+			{
+				if (!(o is DictionaryEntry))
+				{
+					return false;
+				}
+				KeyValuePair<object, object> entry = (KeyValuePair<object, object>)o;
+				if (entry.Key is int)
+				{
+					int key = (int)entry.Key;
+					object value = entry.Value;
+					T existing = this._enclosing._enclosing.Get(key);
+					return value == existing || (existing != null && existing.Equals(value));
+				}
+				return false;
+			}
+
+			public override int Count
+			{
+				get
+				{
+					return this._enclosing._enclosing.Size();
+				}
+			}
+
+			internal AbstractEntrySet(AbstractEdgeMap<T> _enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly AbstractEdgeMap<T> _enclosing;
+		}
+
+		public abstract bool ContainsKey(int arg1);
+
+		public abstract ICollection<KeyValuePair<int, T>> EntrySet();
+
+		public abstract T Get(int arg1);
+
+		public abstract bool IsEmpty();
+
+		public abstract int Size();
+
+		public abstract IDictionary<int, T> ToMap();
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs b/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
new file mode 100644
index 000000000..69fb4d6d5
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/ArrayEdgeMap.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.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+	/// <author>sam</author>
+	public class ArrayEdgeMap<T> : AbstractEdgeMap<T>
+	{
+		private readonly T[] arrayData;
+
+		private int size;
+
+		public ArrayEdgeMap(int minIndex, int maxIndex) : base(minIndex, maxIndex)
+		{
+			arrayData = (T[])new object[maxIndex - minIndex + 1];
+		}
+
+		public override int Size()
+		{
+			return size;
+		}
+
+		public override bool IsEmpty()
+		{
+			return size == 0;
+		}
+
+		public override bool ContainsKey(int key)
+		{
+			return Get(key) != null;
+		}
+
+		public override T Get(int key)
+		{
+			if (key < minIndex || key > maxIndex)
+			{
+				return null;
+			}
+			return arrayData[key - minIndex];
+		}
+
+		public override AbstractEdgeMap<T> Put(int key, T value)
+		{
+			if (key >= minIndex && key <= maxIndex)
+			{
+				T existing = arrayData[key - minIndex];
+				arrayData[key - minIndex] = value;
+				if (existing == null && value != null)
+				{
+					size++;
+				}
+				else
+				{
+					if (existing != null && value == null)
+					{
+						size--;
+					}
+				}
+			}
+			return this;
+		}
+
+		public override AbstractEdgeMap<T> Remove(int key)
+		{
+			return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(key, null));
+		}
+
+		public override AbstractEdgeMap<T> PutAll<_T0>(EdgeMap<_T0> m)
+		{
+			if (m.IsEmpty())
+			{
+				return this;
+			}
+			if (m is Antlr4.Runtime.Dfa.ArrayEdgeMap<object>)
+			{
+				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);
+				for (int i = minOverlap; i <= maxOverlap; i++)
+				{
+					T target = other.arrayData[i - other.minIndex];
+					if (target != null)
+					{
+						T current = this.arrayData[i - this.minIndex];
+						this.arrayData[i - this.minIndex] = target;
+						size += (current != null ? 0 : 1);
+					}
+				}
+				return this;
+			}
+			else
+			{
+				if (m is SingletonEdgeMap<object>)
+				{
+					SingletonEdgeMap<T> other = (SingletonEdgeMap<T>)m;
+					System.Diagnostics.Debug.Assert(!other.IsEmpty());
+					return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(other.GetKey(), other.GetValue())
+						);
+				}
+				else
+				{
+					if (m is SparseEdgeMap<object>)
+					{
+						SparseEdgeMap<T> other = (SparseEdgeMap<T>)m;
+						int[] keys = other.GetKeys();
+						IList<T> values = other.GetValues();
+						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 %s is supported yet."
+							, m.GetType().FullName));
+					}
+				}
+			}
+		}
+
+		public override AbstractEdgeMap<T> Clear()
+		{
+			Arrays.Fill(arrayData, null);
+			return this;
+		}
+
+		public override IDictionary<int, T> ToMap()
+		{
+			if (IsEmpty())
+			{
+				return Sharpen.Collections.EmptyMap();
+			}
+			IDictionary<int, T> result = new LinkedHashMap<int, T>();
+			for (int i = 0; i < arrayData.Length; i++)
+			{
+				if (arrayData[i] == null)
+				{
+					continue;
+				}
+				result.Put(i + minIndex, arrayData[i]);
+			}
+			return result;
+		}
+
+		public override ICollection<KeyValuePair<int, T>> EntrySet()
+		{
+			return new ArrayEdgeMap.EntrySet(this);
+		}
+
+		private class EntrySet : AbstractEdgeMap.AbstractEntrySet
+		{
+			public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+			{
+				return new ArrayEdgeMap.EntryIterator(this);
+			}
+
+			internal EntrySet(ArrayEdgeMap<T> _enclosing) : base(_enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly ArrayEdgeMap<T> _enclosing;
+		}
+
+		private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
+		{
+			private int current;
+
+			private int currentIndex;
+
+			public override bool HasNext()
+			{
+				return this.current < this._enclosing.Size();
+			}
+
+			public override KeyValuePair<int, T> Next()
+			{
+				if (this.current >= this._enclosing.Size())
+				{
+					throw new NoSuchElementException();
+				}
+				while (this._enclosing.arrayData[this.currentIndex] == null)
+				{
+					this.currentIndex++;
+				}
+				this.current++;
+				this.currentIndex++;
+				return new _KeyValuePair_193(this);
+			}
+
+			private sealed class _KeyValuePair_193 : KeyValuePair<int, T>
+			{
+				public _KeyValuePair_193()
+				{
+					this.key = this._enclosing._enclosing.minIndex + this._enclosing.currentIndex - 1;
+					this.value = this._enclosing._enclosing.arrayData[this._enclosing.currentIndex - 
+						1];
+				}
+
+				private readonly int key;
+
+				private readonly T value;
+
+				public int Key
+				{
+					get
+					{
+						return this.key;
+					}
+				}
+
+				public T Value
+				{
+					get
+					{
+						return this.value;
+					}
+				}
+
+				public T SetValue(T value)
+				{
+					throw new NotSupportedException("Not supported yet.");
+				}
+			}
+
+			public override void Remove()
+			{
+				throw new NotSupportedException("Not supported yet.");
+			}
+
+			internal EntryIterator(ArrayEdgeMap<T> _enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly ArrayEdgeMap<T> _enclosing;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/DFA.cs b/Antlr4.Runtime/Dfa/DFA.cs
new file mode 100644
index 000000000..0f8fdeb51
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/DFA.cs
@@ -0,0 +1,144 @@
+/*
+ * [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.Dfa;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+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.IDictionary{K, V}">System.Collections.IDictionary&lt;K, V&gt;
+		/// 	</see>
+		/// so we can get old state back
+		/// (
+		/// <see cref="Sharpen.Set{E}">Sharpen.Set&lt;E&gt;</see>
+		/// only allows you to see if it's there).
+		/// </remarks>
+		[NotNull]
+		public readonly ConcurrentMap<DFAState, DFAState> states = new ConcurrentHashMap<
+			DFAState, DFAState>();
+
+		[Nullable]
+		public readonly AtomicReference<DFAState> s0 = new AtomicReference<DFAState>();
+
+		[Nullable]
+		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 readonly AtomicInteger nextStateNumber = new AtomicInteger();
+
+		/// <summary>
+		/// Set of configs for a DFA state with at least one conflict? Mainly used as "return value"
+		/// from
+		/// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.TokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.TokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+		/// 	</see>
+		/// for retry.
+		/// </summary>
+		public DFA(ATNState atnStartState) : this(atnStartState, 0)
+		{
+		}
+
+		public DFA(ATNState atnStartState, int decision)
+		{
+			//	public OrderedHashSet<ATNConfig> conflictSet;
+			this.atnStartState = atnStartState;
+			this.decision = decision;
+		}
+
+		public virtual bool IsEmpty()
+		{
+			return s0.Get() == null && s0full.Get() == null;
+		}
+
+		public virtual bool IsContextSensitive()
+		{
+			return s0full.Get() != null;
+		}
+
+		public virtual DFAState AddState(DFAState state)
+		{
+			state.stateNumber = nextStateNumber.GetAndIncrement();
+			DFAState existing = states.PutIfAbsent(state, state);
+			if (existing != null)
+			{
+				return existing;
+			}
+			return state;
+		}
+
+		public override string ToString()
+		{
+			return ToString(null);
+		}
+
+		public virtual string ToString(string[] tokenNames)
+		{
+			if (s0.Get() == null)
+			{
+				return string.Empty;
+			}
+			DFASerializer serializer = new DFASerializer(this, tokenNames);
+			return serializer.ToString();
+		}
+
+		public virtual string ToString(string[] tokenNames, string[] ruleNames)
+		{
+			if (s0.Get() == null)
+			{
+				return string.Empty;
+			}
+			DFASerializer serializer = new DFASerializer(this, tokenNames, 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/Antlr4.Runtime/Dfa/DFASerializer.cs b/Antlr4.Runtime/Dfa/DFASerializer.cs
new file mode 100644
index 000000000..813afe686
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/DFASerializer.cs
@@ -0,0 +1,222 @@
+/*
+ * [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.Dfa;
+using Antlr4.Runtime.Misc;
+using 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]
+		internal readonly DFA dfa;
+
+		[Nullable]
+		internal readonly string[] tokenNames;
+
+		[Nullable]
+		internal readonly string[] ruleNames;
+
+		[Nullable]
+		internal readonly ATN atn;
+
+		public DFASerializer(DFA dfa, string[] tokenNames) : this(dfa, tokenNames, null, 
+			null)
+		{
+		}
+
+		public DFASerializer(DFA dfa, Recognizer<object, object> parser) : this(dfa, parser
+			 != null ? parser.GetTokenNames() : null, parser != null ? parser.GetRuleNames()
+			 : null, parser != null ? parser.GetATN() : null)
+		{
+		}
+
+		public DFASerializer(DFA dfa, string[] tokenNames, string[] ruleNames, ATN atn)
+		{
+			this.dfa = dfa;
+			this.tokenNames = tokenNames;
+			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)
+			{
+				IList<DFAState> states = new AList<DFAState>(dfa.states.Values);
+				states.Sort(new _IComparer_85());
+				foreach (DFAState s in states)
+				{
+					IDictionary<int, DFAState> edges = s.GetEdgeMap();
+					IDictionary<int, DFAState> contextEdges = s.GetContextEdgeMap();
+					foreach (KeyValuePair<int, DFAState> entry in edges.EntrySet())
+					{
+						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.EntrySet())
+						{
+							buf.Append(GetStateString(s)).Append("-").Append(GetContextLabel(entry_1.Key)).Append
+								("->").Append(GetStateString(entry_1.Value)).Append("\n");
+						}
+					}
+				}
+			}
+			string output = buf.ToString();
+			//return Utils.sortLinesInString(output);
+			return output;
+		}
+
+		private sealed class _IComparer_85 : IComparer<DFAState>
+		{
+			public _IComparer_85()
+			{
+			}
+
+			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)
+		{
+			string label;
+			if (i == -1)
+			{
+				return "EOF";
+			}
+			if (tokenNames != null)
+			{
+				label = tokenNames[i];
+			}
+			else
+			{
+				label = i.ToString();
+			}
+			return label;
+		}
+
+		internal virtual string GetStateString(DFAState s)
+		{
+			if (s == ATNSimulator.Error)
+			{
+				return "ERROR";
+			}
+			int n = s.stateNumber;
+			string stateStr = "s" + n;
+			if (s.isAcceptState)
+			{
+				if (s.predicates != null)
+				{
+					stateStr = ":s" + n + "=>" + Arrays.ToString(s.predicates);
+				}
+				else
+				{
+					stateStr = ":s" + n + "=>" + s.prediction;
+				}
+			}
+			if (s.IsContextSensitive())
+			{
+				stateStr += "*";
+				foreach (ATNConfig config in s.configs)
+				{
+					if (config.GetReachesIntoOuterContext())
+					{
+						stateStr += "*";
+						break;
+					}
+				}
+			}
+			return stateStr;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/DFAState.cs b/Antlr4.Runtime/Dfa/DFAState.cs
new file mode 100644
index 000000000..ca8d5a824
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/DFAState.cs
@@ -0,0 +1,349 @@
+/*
+ * [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.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using 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-&gt;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/>
+	/// 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.
+	/// </remarks>
+	public class DFAState
+	{
+		public int stateNumber = -1;
+
+		[NotNull]
+		public readonly ATNConfigSet configs;
+
+		/// <summary>
+		/// <code>edges.get(symbol)</code>
+		/// points to target of symbol.
+		/// </summary>
+		[Nullable]
+		private AbstractEdgeMap<Antlr4.Runtime.Dfa.DFAState> edges;
+
+		private readonly int minSymbol;
+
+		private readonly int maxSymbol;
+
+		public bool isAcceptState = false;
+
+		/// <summary>
+		/// if accept state, what ttype do we match or alt do we predict?
+		/// This is set to
+		/// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber">Antlr4.Runtime.Atn.ATN.InvalidAltNumber
+		/// 	</see>
+		/// when
+		/// <see cref="predicates">predicates</see>
+		/// <code>!=null</code>
+		/// .
+		/// </summary>
+		public int prediction;
+
+		public int lexerRuleIndex = -1;
+
+		public int lexerActionIndex = -1;
+
+		/// <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>
+		[Nullable]
+		private 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)
+		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)
+		/// 	</see>
+		/// .
+		/// </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)
+			{
+				// if accept, exec action in what rule?
+				// if accept, exec what action?
+				// never null; at least SemanticContext.NONE
+				this.alt = alt;
+				this.pred = pred;
+			}
+
+			public override string ToString()
+			{
+				return "(" + pred + ", " + alt + ")";
+			}
+		}
+
+		public DFAState(ATNConfigSet configs, int minSymbol, int maxSymbol)
+		{
+			this.configs = configs;
+			this.minSymbol = minSymbol;
+			this.maxSymbol = maxSymbol;
+		}
+
+		public bool IsContextSensitive()
+		{
+			return contextEdges != null;
+		}
+
+		public bool IsContextSymbol(int symbol)
+		{
+			if (!IsContextSensitive() || symbol < minSymbol)
+			{
+				return false;
+			}
+			return contextSymbols.Get(symbol - minSymbol);
+		}
+
+		public void SetContextSymbol(int symbol)
+		{
+			System.Diagnostics.Debug.Assert(IsContextSensitive());
+			if (symbol < minSymbol)
+			{
+				return;
+			}
+			contextSymbols.Set(symbol - minSymbol);
+		}
+
+		public virtual void SetContextSensitive(ATN atn)
+		{
+			lock (this)
+			{
+				System.Diagnostics.Debug.Assert(!configs.IsOutermostConfigSet());
+				if (IsContextSensitive())
+				{
+					return;
+				}
+				contextSymbols = new BitSet();
+				contextEdges = new SingletonEdgeMap<DFAState>(-1, atn.states.Count - 1);
+			}
+		}
+
+		public virtual DFAState GetTarget(int symbol)
+		{
+			if (edges == null)
+			{
+				return null;
+			}
+			return edges.Get(symbol);
+		}
+
+		public virtual void SetTarget(int symbol, DFAState target)
+		{
+			lock (this)
+			{
+				if (edges == null)
+				{
+					edges = new SingletonEdgeMap<DFAState>(minSymbol, maxSymbol);
+				}
+				edges = edges.Put(symbol, target);
+			}
+		}
+
+		public virtual IDictionary<int, DFAState> GetEdgeMap()
+		{
+			if (edges == null)
+			{
+				return Sharpen.Collections.EmptyMap();
+			}
+			return edges.ToMap();
+		}
+
+		public virtual DFAState GetContextTarget(int invokingState)
+		{
+			if (contextEdges == null)
+			{
+				return null;
+			}
+			if (invokingState == PredictionContext.EmptyFullStateKey)
+			{
+				invokingState = -1;
+			}
+			return contextEdges.Get(invokingState);
+		}
+
+		public virtual void SetContextTarget(int invokingState, DFAState target)
+		{
+			lock (this)
+			{
+				if (contextEdges == null)
+				{
+					throw new InvalidOperationException("The state is not context sensitive.");
+				}
+				if (invokingState == PredictionContext.EmptyFullStateKey)
+				{
+					invokingState = -1;
+				}
+				contextEdges = contextEdges.Put(invokingState, target);
+			}
+		}
+
+		public virtual IDictionary<int, DFAState> GetContextEdgeMap()
+		{
+			if (contextEdges == null)
+			{
+				return Sharpen.Collections.EmptyMap();
+			}
+			IDictionary<int, DFAState> map = contextEdges.ToMap();
+			if (map.ContainsKey(-1))
+			{
+				if (map.Count == 1)
+				{
+					return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.
+						Get(-1));
+				}
+				else
+				{
+					try
+					{
+						map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+					}
+					catch (NotSupportedException)
+					{
+						// handles read only, non-singleton maps
+						map = new LinkedHashMap<int, DFAState>(map);
+						map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+					}
+				}
+			}
+			return map;
+		}
+
+		public override int GetHashCode()
+		{
+			if (configs == null)
+			{
+				return 1;
+			}
+			return configs.GetHashCode();
+		}
+
+		/// <summary>
+		/// Two
+		/// <see cref="DFAState">DFAState</see>
+		/// 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/>
+		/// 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)
+		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)
+		/// 	</see>
+		/// we need to know if any other state
+		/// exists that has this exact set of ATN configurations. The
+		/// <see cref="stateNumber">stateNumber</see>
+		/// is irrelevant.
+		/// </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/Antlr4.Runtime/Dfa/EdgeMap.cs b/Antlr4.Runtime/Dfa/EdgeMap.cs
new file mode 100644
index 000000000..e80d43f70
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/EdgeMap.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.Collections.Generic;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+	/// <author>Sam Harwell</author>
+	public interface EdgeMap<T>
+	{
+		int Size();
+
+		bool IsEmpty();
+
+		bool ContainsKey(int key);
+
+		[Nullable]
+		T Get(int key);
+
+		[NotNull]
+		EdgeMap<T> Put(int key, T value);
+
+		[NotNull]
+		EdgeMap<T> Remove(int key);
+
+		[NotNull]
+		EdgeMap<T> PutAll<_T0>(EdgeMap<_T0> m) where _T0:T;
+
+		[NotNull]
+		EdgeMap<T> Clear();
+
+		[NotNull]
+		IDictionary<int, T> ToMap();
+
+		[NotNull]
+		ICollection<KeyValuePair<int, T>> EntrySet();
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/LexerDFASerializer.cs b/Antlr4.Runtime/Dfa/LexerDFASerializer.cs
new file mode 100644
index 000000000..0f6add7b4
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/LexerDFASerializer.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.Dfa;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+	public class LexerDFASerializer : DFASerializer
+	{
+		public LexerDFASerializer(DFA dfa) : base(dfa, (string[])null)
+		{
+		}
+
+		[NotNull]
+		protected internal override string GetEdgeLabel(int i)
+		{
+			return "'" + (char)i + "'";
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs b/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs
new file mode 100644
index 000000000..11c87246a
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs
@@ -0,0 +1,238 @@
+/*
+ * [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.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+	/// <author>Sam Harwell</author>
+	public class SingletonEdgeMap<T> : AbstractEdgeMap<T>
+	{
+		private readonly int key;
+
+		private readonly T value;
+
+		public SingletonEdgeMap(int minIndex, int maxIndex) : base(minIndex, maxIndex)
+		{
+			this.key = 0;
+			this.value = null;
+		}
+
+		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 virtual int GetKey()
+		{
+			return key;
+		}
+
+		public virtual T GetValue()
+		{
+			return value;
+		}
+
+		public override int Size()
+		{
+			return value != null ? 1 : 0;
+		}
+
+		public override bool IsEmpty()
+		{
+			return value == null;
+		}
+
+		public override bool ContainsKey(int key)
+		{
+			return key == this.key && value != null;
+		}
+
+		public override T Get(int key)
+		{
+			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 Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex);
+			}
+			return this;
+		}
+
+		public override AbstractEdgeMap<T> Clear()
+		{
+			if (this.value != null)
+			{
+				return new Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex);
+			}
+			return this;
+		}
+
+		public override IDictionary<int, T> ToMap()
+		{
+			if (IsEmpty())
+			{
+				return Sharpen.Collections.EmptyMap();
+			}
+			return Sharpen.Collections.SingletonMap(key, value);
+		}
+
+		public override ICollection<KeyValuePair<int, T>> EntrySet()
+		{
+			return new SingletonEdgeMap.EntrySet(this);
+		}
+
+		private class EntrySet : AbstractEdgeMap.AbstractEntrySet
+		{
+			public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+			{
+				return new SingletonEdgeMap.EntryIterator(this);
+			}
+
+			internal EntrySet(SingletonEdgeMap<T> _enclosing) : base(_enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly SingletonEdgeMap<T> _enclosing;
+		}
+
+		private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
+		{
+			private int current;
+
+			public override bool HasNext()
+			{
+				return this.current < this._enclosing.Size();
+			}
+
+			public override KeyValuePair<int, T> Next()
+			{
+				if (this.current >= this._enclosing.Size())
+				{
+					throw new NoSuchElementException();
+				}
+				this.current++;
+				return new _KeyValuePair_166(this);
+			}
+
+			private sealed class _KeyValuePair_166 : KeyValuePair<int, T>
+			{
+				public _KeyValuePair_166()
+				{
+					this.key = this._enclosing._enclosing._enclosing.key;
+					this.value = this._enclosing._enclosing._enclosing.value;
+				}
+
+				private readonly int key;
+
+				private readonly T value;
+
+				public int Key
+				{
+					get
+					{
+						return this.key;
+					}
+				}
+
+				public T Value
+				{
+					get
+					{
+						return this.value;
+					}
+				}
+
+				public T SetValue(T value)
+				{
+					throw new NotSupportedException("Not supported yet.");
+				}
+			}
+
+			public override void Remove()
+			{
+				throw new NotSupportedException("Not supported yet.");
+			}
+
+			internal EntryIterator(SingletonEdgeMap<T> _enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly SingletonEdgeMap<T> _enclosing;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Dfa/SparseEdgeMap.cs b/Antlr4.Runtime/Dfa/SparseEdgeMap.cs
new file mode 100644
index 000000000..1c55a4cc5
--- /dev/null
+++ b/Antlr4.Runtime/Dfa/SparseEdgeMap.cs
@@ -0,0 +1,293 @@
+/*
+ * [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.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime.Dfa
+{
+	/// <author>Sam Harwell</author>
+	public class SparseEdgeMap<T> : AbstractEdgeMap<T>
+	{
+		private const int DefaultMaxSize = 5;
+
+		private readonly int[] keys;
+
+		private readonly IList<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 AList<T>(maxSparseSize);
+		}
+
+		private SparseEdgeMap(Antlr4.Runtime.Dfa.SparseEdgeMap<T> map, int maxSparseSize)
+			 : base(map.minIndex, map.maxIndex)
+		{
+			if (maxSparseSize < map.values.Count)
+			{
+				throw new ArgumentException();
+			}
+			keys = Arrays.CopyOf(map.keys, maxSparseSize);
+			values = new AList<T>(maxSparseSize);
+			Sharpen.Collections.AddAll(values, map.values);
+		}
+
+		public virtual int[] GetKeys()
+		{
+			return keys;
+		}
+
+		public virtual IList<T> GetValues()
+		{
+			return values;
+		}
+
+		public virtual int GetMaxSparseSize()
+		{
+			return keys.Length;
+		}
+
+		public override int Size()
+		{
+			return values.Count;
+		}
+
+		public override bool IsEmpty()
+		{
+			return values.IsEmpty();
+		}
+
+		public override bool ContainsKey(int key)
+		{
+			return Get(key) != null;
+		}
+
+		public override T Get(int key)
+		{
+			int index = System.Array.BinarySearch(keys, 0, Size(), 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 ((Antlr4.Runtime.Dfa.SparseEdgeMap<T>)Remove(key));
+			}
+			lock (values)
+			{
+				int index = System.Array.BinarySearch(keys, 0, Size(), key);
+				if (index >= 0)
+				{
+					// replace existing entry
+					values.Set(index, value);
+					return this;
+				}
+				System.Diagnostics.Debug.Assert(index < 0 && value != null);
+				int insertIndex = -index - 1;
+				if (Size() < GetMaxSparseSize() && insertIndex == Size())
+				{
+					// stay sparse and add new entry
+					keys[insertIndex] = key;
+					values.AddItem(value);
+					return this;
+				}
+				int desiredSize = Size() >= GetMaxSparseSize() ? GetMaxSparseSize() * 2 : GetMaxSparseSize
+					();
+				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, resized
+						.keys.Length - insertIndex - 1);
+					resized.keys[insertIndex] = key;
+					resized.values.Add(insertIndex, value);
+					return resized;
+				}
+			}
+		}
+
+		public override AbstractEdgeMap<T> Remove(int key)
+		{
+			int index = System.Array.BinarySearch(keys, 0, Size(), key);
+			if (index < 0)
+			{
+				return this;
+			}
+			if (index == values.Count - 1)
+			{
+				values.Remove(index);
+				return this;
+			}
+			Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap
+				<T>(this, GetMaxSparseSize());
+			System.Array.Copy(result.keys, index + 1, result.keys, index, Size() - index - 1);
+			result.values.Remove(index);
+			return result;
+		}
+
+		public override AbstractEdgeMap<T> Clear()
+		{
+			if (IsEmpty())
+			{
+				return this;
+			}
+			Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap
+				<T>(this, GetMaxSparseSize());
+			result.values.Clear();
+			return result;
+		}
+
+		public override IDictionary<int, T> ToMap()
+		{
+			if (IsEmpty())
+			{
+				return Sharpen.Collections.EmptyMap();
+			}
+			IDictionary<int, T> result = new LinkedHashMap<int, T>();
+			for (int i = 0; i < Size(); i++)
+			{
+				result.Put(keys[i], values[i]);
+			}
+			return result;
+		}
+
+		public override ICollection<KeyValuePair<int, T>> EntrySet()
+		{
+			return new SparseEdgeMap.EntrySet(this);
+		}
+
+		private class EntrySet : AbstractEdgeMap.AbstractEntrySet
+		{
+			public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+			{
+				return new SparseEdgeMap.EntryIterator(this);
+			}
+
+			internal EntrySet(SparseEdgeMap<T> _enclosing) : base(_enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly SparseEdgeMap<T> _enclosing;
+		}
+
+		private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
+		{
+			private int current;
+
+			public override bool HasNext()
+			{
+				return this.current < this._enclosing.Size();
+			}
+
+			public override KeyValuePair<int, T> Next()
+			{
+				if (this.current >= this._enclosing.Size())
+				{
+					throw new NoSuchElementException();
+				}
+				this.current++;
+				return new _KeyValuePair_226(this);
+			}
+
+			private sealed class _KeyValuePair_226 : KeyValuePair<int, T>
+			{
+				public _KeyValuePair_226()
+				{
+					this.key = this._enclosing._enclosing.keys[this._enclosing.current - 1];
+					this.value = this._enclosing._enclosing.values[this._enclosing.current - 1];
+				}
+
+				private readonly int key;
+
+				private readonly T value;
+
+				public int Key
+				{
+					get
+					{
+						return this.key;
+					}
+				}
+
+				public T Value
+				{
+					get
+					{
+						return this.value;
+					}
+				}
+
+				public T SetValue(T value)
+				{
+					throw new NotSupportedException("Not supported yet.");
+				}
+			}
+
+			public override void Remove()
+			{
+				throw new NotSupportedException("Not supported yet.");
+			}
+
+			internal EntryIterator(SparseEdgeMap<T> _enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly SparseEdgeMap<T> _enclosing;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/DiagnosticErrorListener.cs b/Antlr4.Runtime/DiagnosticErrorListener.cs
new file mode 100644
index 000000000..da09423a3
--- /dev/null
+++ b/Antlr4.Runtime/DiagnosticErrorListener.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 Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	public class DiagnosticErrorListener : BaseErrorListener
+	{
+		public override void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, 
+			int stopIndex, BitSet ambigAlts, ATNConfigSet configs)
+		{
+			string format = "reportAmbiguity d=%s: ambigAlts=%s, input='%s'";
+			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
+				, dfa.decision), ambigAlts, ((TokenStream)recognizer.GetInputStream()).GetText(Interval
+				.Of(startIndex, stopIndex))));
+		}
+
+		public override void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int 
+			startIndex, int stopIndex, SimulatorState initialState)
+		{
+			string format = "reportAttemptingFullContext d=%s, input='%s'";
+			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
+				, dfa.decision), ((TokenStream)recognizer.GetInputStream()).GetText(Interval.Of(
+				startIndex, stopIndex))));
+		}
+
+		public override void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
+			, int stopIndex, SimulatorState acceptState)
+		{
+			string format = "reportContextSensitivity d=%s, input='%s'";
+			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
+				, dfa.decision), ((TokenStream)recognizer.GetInputStream()).GetText(Interval.Of(
+				startIndex, stopIndex))));
+		}
+
+		protected internal virtual string GetDecisionDescription(Parser recognizer, int decision
+			)
+		{
+			return Sharpen.Extensions.ToString(decision);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/FailedPredicateException.cs b/Antlr4.Runtime/FailedPredicateException.cs
new file mode 100644
index 000000000..b60a15567
--- /dev/null
+++ b/Antlr4.Runtime/FailedPredicateException.cs
@@ -0,0 +1,110 @@
+/*
+ * [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 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, ((TokenStream)recognizer
+			.GetInputStream()), recognizer._ctx)
+		{
+			ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
+			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.SetOffendingToken(recognizer.GetCurrentToken());
+		}
+
+		public virtual int GetRuleIndex()
+		{
+			return ruleIndex;
+		}
+
+		public virtual int GetPredIndex()
+		{
+			return predicateIndex;
+		}
+
+		[Nullable]
+		public virtual string GetPredicate()
+		{
+			return predicate;
+		}
+
+		[NotNull]
+		private static string FormatMessage(string predicate, string message)
+		{
+			if (message != null)
+			{
+				return message;
+			}
+			return string.Format("failed predicate: {%s}?", predicate);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/InputMismatchException.cs b/Antlr4.Runtime/InputMismatchException.cs
new file mode 100644
index 000000000..bc6961c34
--- /dev/null
+++ b/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 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, ((TokenStream
+			)recognizer.GetInputStream()), recognizer._ctx)
+		{
+			this.SetOffendingToken(recognizer.GetCurrentToken());
+		}
+	}
+}
diff --git a/Antlr4.Runtime/IntStream.cs b/Antlr4.Runtime/IntStream.cs
new file mode 100644
index 000000000..c6bd005f5
--- /dev/null
+++ b/Antlr4.Runtime/IntStream.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 Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using 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()">Mark()</see>
+	/// .
+	/// <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:
+	/// <ul>
+	/// <li>
+	/// <see cref="La(int)">La(int)</see>
+	/// </li>
+	/// <li>
+	/// <see cref="Consume()">Consume()</see>
+	/// </li>
+	/// <li>
+	/// <see cref="Size()">Size()</see>
+	/// </li>
+	/// </ul>
+	/// </remarks>
+	public abstract class IntStream
+	{
+		/// <summary>
+		/// The value returned by
+		/// <see cref="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="GetSourceName()">GetSourceName()</see>
+		/// when the actual name of the
+		/// underlying source is not known.
+		/// </summary>
+		public const string UnknownSourceName = "<unknown>";
+
+		/// <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
+		/// <code>index()</code>
+		/// after calling this method.</li>
+		/// <li><strong>Ordered lookahead:</strong> The value of
+		/// <code>LA(1)</code>
+		/// before
+		/// calling this method becomes the value of
+		/// <code>LA(-1)</code>
+		/// after calling
+		/// this method.</li>
+		/// </ul>
+		/// Note that calling this method does not guarantee that
+		/// <code>index()</code>
+		/// is
+		/// incremented by exactly 1, as that would preclude the ability to implement
+		/// filtering streams (e.g.
+		/// <see cref="CommonTokenStream">CommonTokenStream</see>
+		/// 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
+		/// <code>LA(1)==</code>
+		/// <see cref="Eof">EOF</see>
+		/// before calling
+		/// <code>consume</code>
+		/// ).
+		/// </exception>
+		public abstract void Consume();
+
+		/// <summary>
+		/// Gets the value of the symbol at offset
+		/// <code>i</code>
+		/// from the current
+		/// position. When
+		/// <code>i==1</code>
+		/// , this method returns the value of the current
+		/// symbol in the stream (which is the next symbol to be consumed). When
+		/// <code>i==-1</code>
+		/// , this method returns the value of the previously read
+		/// symbol in the stream. It is not valid to call this method with
+		/// <code>i==0</code>
+		/// , 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:
+		/// <ul>
+		/// <li>
+		/// <code>i&gt;0</code>
+		/// </li>
+		/// <li>
+		/// <code>i==-1</code>
+		/// and
+		/// <see cref="Index()">index()</see>
+		/// returns a value greater
+		/// than the value of
+		/// <code>index()</code>
+		/// after the stream was constructed
+		/// and
+		/// <code>LA(1)</code>
+		/// was called in that order. Specifying the current
+		/// <code>index()</code>
+		/// 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
+		/// <code>LA(1)</code>
+		/// allows for lazily initialized streams.</li>
+		/// <li>
+		/// <code>LA(i)</code>
+		/// refers to a symbol consumed within a marked region
+		/// that has not yet been released.</li>
+		/// </ul>
+		/// If
+		/// <code>i</code>
+		/// represents a position at or beyond the end of the stream,
+		/// this method returns
+		/// <see cref="Eof">Eof</see>
+		/// .
+		/// <p/>
+		/// The return value is unspecified if
+		/// <code>i&lt;0</code>
+		/// and fewer than
+		/// <code>-i</code>
+		/// calls to
+		/// <see cref="Consume()">consume()</see>
+		/// have occurred from the beginning of
+		/// the stream before calling this method.
+		/// </summary>
+		/// <exception cref="System.NotSupportedException">
+		/// if the stream does not support
+		/// retrieving the value of the specified symbol
+		/// </exception>
+		public abstract 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
+		/// <code>mark()</code>
+		/// 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
+		/// <code>int</code>
+		/// ) 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
+		/// <code>mark()</code>
+		/// /
+		/// <code>release()</code>
+		/// 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/>
+		/// The behavior of this method is unspecified if no call to an
+		/// <see cref="IntStream">initializing method</see>
+		/// 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
+		/// <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.
+		/// <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>
+		public abstract int Mark();
+
+		/// <summary>
+		/// This method releases a marked range created by a call to
+		/// <see cref="Mark()">mark()</see>
+		/// . Calls to
+		/// <code>release()</code>
+		/// must appear in the
+		/// reverse order of the corresponding calls to
+		/// <code>mark()</code>
+		/// . If a mark is
+		/// released twice, or if marks are not released in reverse order of the
+		/// corresponding calls to
+		/// <code>mark()</code>
+		/// , the behavior is unspecified.
+		/// <p/>
+		/// For more information and an example, see
+		/// <see cref="Mark()">Mark()</see>
+		/// .
+		/// </summary>
+		/// <param name="marker">
+		/// A marker returned by a call to
+		/// <code>mark()</code>
+		/// .
+		/// </param>
+		/// <seealso cref="Mark()">Mark()</seealso>
+		public abstract void Release(int marker);
+
+		/// <summary>
+		/// Return the index into the stream of the input symbol referred to by
+		/// <code>LA(1)</code>
+		/// .
+		/// <p/>
+		/// The behavior of this method is unspecified if no call to an
+		/// <see cref="IntStream">initializing method</see>
+		/// has occurred after this stream was
+		/// constructed.
+		/// </summary>
+		public abstract int Index();
+
+		/// <summary>
+		/// Set the input cursor to the position indicated by
+		/// <code>index</code>
+		/// . If the
+		/// specified index lies past the end of the stream, the operation behaves as
+		/// though
+		/// <code>index</code>
+		/// 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
+		/// <code>index</code>
+		/// . Specifically,
+		/// implementations which filter their sources should automatically
+		/// adjust
+		/// <code>index</code>
+		/// forward the minimum amount required for the
+		/// operation to target a non-ignored symbol.</li>
+		/// <li>
+		/// <code>LA(1)</code>
+		/// returns
+		/// <see cref="Eof">Eof</see>
+		/// </li>
+		/// </ul>
+		/// This operation is guaranteed to not throw an exception if
+		/// <code>index</code>
+		/// lies within a marked region. For more information on marked regions, see
+		/// <see cref="Mark()">Mark()</see>
+		/// . The behavior of this method is unspecified if no call to
+		/// an
+		/// <see cref="IntStream">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
+		/// <code>index</code>
+		/// is less than 0
+		/// </exception>
+		/// <exception cref="System.NotSupportedException">
+		/// if the stream does not support
+		/// seeking to the specified index
+		/// </exception>
+		public abstract 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>
+		public abstract int Size();
+
+		/// <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="UnknownSourceName">UnknownSourceName</see>
+		/// .
+		/// </remarks>
+		[NotNull]
+		public abstract string GetSourceName();
+	}
+}
diff --git a/Antlr4.Runtime/Lexer.cs b/Antlr4.Runtime/Lexer.cs
new file mode 100644
index 000000000..7730e850a
--- /dev/null
+++ b/Antlr4.Runtime/Lexer.cs
@@ -0,0 +1,567 @@
+/*
+ * [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 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>, TokenSource
+	{
+		public const int DefaultMode = 0;
+
+		public const int More = -2;
+
+		public const int Skip = -3;
+
+		public const int DefaultTokenChannel = Token.DefaultChannel;
+
+		public const int Hidden = Token.HiddenChannel;
+
+		public const int MinCharValue = '\u0000';
+
+		public const int MaxCharValue = '\uFFFE';
+
+		public CharStream _input;
+
+		protected internal Tuple<TokenSource, CharStream> _tokenFactorySourcePair;
+
+		/// <summary>How to create token objects</summary>
+		protected internal TokenFactory _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>
+		public Token _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>
+		public int _tokenStartCharIndex = -1;
+
+		/// <summary>The line on which the first character of the token resides</summary>
+		public int _tokenStartLine;
+
+		/// <summary>The character position of first character within the line</summary>
+		public int _tokenStartCharPositionInLine;
+
+		/// <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>
+		public bool _hitEOF;
+
+		/// <summary>The channel number for the current token</summary>
+		public int _channel;
+
+		/// <summary>The token type for the current token</summary>
+		public int _type;
+
+		public readonly IntegerStack _modeStack = new IntegerStack();
+
+		public 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>
+		public string _text;
+
+		public Lexer(CharStream input)
+		{
+			this._input = input;
+			this._tokenFactorySourcePair = Tuple.Create(this, input);
+		}
+
+		public virtual void Reset()
+		{
+			// wack Lexer state variables
+			if (_input != null)
+			{
+				_input.Seek(0);
+			}
+			// rewind the input
+			_token = null;
+			_type = Token.InvalidType;
+			_channel = Token.DefaultChannel;
+			_tokenStartCharIndex = -1;
+			_tokenStartCharPositionInLine = -1;
+			_tokenStartLine = -1;
+			_text = null;
+			_hitEOF = false;
+			_mode = Antlr4.Runtime.Lexer.DefaultMode;
+			_modeStack.Clear();
+			GetInterpreter().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 Token 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 = Token.DefaultChannel;
+					_tokenStartCharIndex = _input.Index();
+					_tokenStartCharPositionInLine = GetInterpreter().GetCharPositionInLine();
+					_tokenStartLine = GetInterpreter().GetLine();
+					_text = null;
+					do
+					{
+						_type = Token.InvalidType;
+						//				System.out.println("nextToken line "+tokenStartLine+" at "+((char)input.LA(1))+
+						//								   " in mode "+mode+
+						//								   " at index "+input.index());
+						int ttype;
+						try
+						{
+							ttype = GetInterpreter().Match(_input, _mode);
+						}
+						catch (LexerNoViableAltException e)
+						{
+							NotifyListeners(e);
+							// report error
+							Recover(e);
+							ttype = Skip;
+						}
+						if (_input.La(1) == IntStream.Eof)
+						{
+							_hitEOF = true;
+						}
+						if (_type == Token.InvalidType)
+						{
+							_type = ttype;
+						}
+						if (_type == Skip)
+						{
+							goto outer_continue;
+						}
+					}
+					while (_type == More);
+					if (_token == null)
+					{
+						Emit();
+					}
+					return _token;
+outer_continue: ;
+				}
+outer_break: ;
+			}
+			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 = Skip;
+		}
+
+		public virtual void More()
+		{
+			_type = 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.IsEmpty())
+			{
+				throw new EmptyStackException();
+			}
+			Mode(_modeStack.Pop());
+			return _mode;
+		}
+
+		public virtual TokenFactory GetTokenFactory()
+		{
+			return _factory;
+		}
+
+		public virtual void SetTokenFactory(TokenFactory factory)
+		{
+			this._factory = factory;
+		}
+
+		/// <summary>Set the char stream and reset the lexer</summary>
+		public virtual void SetInputStream(CharStream input)
+		{
+			this._input = null;
+			this._tokenFactorySourcePair = Tuple.Create(this, _input);
+			Reset();
+			this._input = input;
+			this._tokenFactorySourcePair = Tuple.Create(this, _input);
+		}
+
+		public virtual string GetSourceName()
+		{
+			return _input.GetSourceName();
+		}
+
+		public override IntStream GetInputStream()
+		{
+			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(Token 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 Token Emit()
+		{
+			Token t = _factory.Create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex
+				, GetCharIndex() - 1, _tokenStartLine, _tokenStartCharPositionInLine);
+			Emit(t);
+			return t;
+		}
+
+		public virtual 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;
+			}
+			Token eof = _factory.Create(_tokenFactorySourcePair, Token.Eof, null, Token.DefaultChannel
+				, _input.Index(), _input.Index() - 1, GetLine(), cpos);
+			Emit(eof);
+			return eof;
+		}
+
+		public virtual int GetLine()
+		{
+			return GetInterpreter().GetLine();
+		}
+
+		public virtual int GetCharPositionInLine()
+		{
+			return GetInterpreter().GetCharPositionInLine();
+		}
+
+		public virtual void SetLine(int line)
+		{
+			GetInterpreter().SetLine(line);
+		}
+
+		public virtual void SetCharPositionInLine(int charPositionInLine)
+		{
+			GetInterpreter().SetCharPositionInLine(charPositionInLine);
+		}
+
+		/// <summary>What is the index of the current character of lookahead?</summary>
+		public virtual int GetCharIndex()
+		{
+			return _input.Index();
+		}
+
+		/// <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>
+		public virtual string GetText()
+		{
+			if (_text != null)
+			{
+				return _text;
+			}
+			return GetInterpreter().GetText(_input);
+		}
+
+		/// <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 void SetText(string text)
+		{
+			this._text = text;
+		}
+
+		/// <summary>Override if emitting multiple tokens.</summary>
+		/// <remarks>Override if emitting multiple tokens.</remarks>
+		public virtual Token GetToken()
+		{
+			return _token;
+		}
+
+		public virtual void SetToken(Token _token)
+		{
+			this._token = _token;
+		}
+
+		public virtual void SetType(int ttype)
+		{
+			_type = ttype;
+		}
+
+		public virtual int GetType()
+		{
+			return _type;
+		}
+
+		public virtual void SetChannel(int channel)
+		{
+			_channel = channel;
+		}
+
+		public virtual int GetChannel()
+		{
+			return _channel;
+		}
+
+		public virtual string[] GetModeNames()
+		{
+			return null;
+		}
+
+		/// <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 override string[] GetTokenNames()
+		{
+			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<Token> GetAllTokens()
+		{
+			IList<Token> tokens = new AList<Token>();
+			Token t = NextToken();
+			while (t.GetType() != Token.Eof)
+			{
+				tokens.AddItem(t);
+				t = NextToken();
+			}
+			return tokens;
+		}
+
+		public virtual void Recover(LexerNoViableAltException e)
+		{
+			if (_input.La(1) != IntStream.Eof)
+			{
+				// skip a char and try again
+				GetInterpreter().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) + "'";
+			ANTLRErrorListener<int> listener = GetErrorListenerDispatch();
+			listener.SyntaxError(this, null, _tokenStartLine, _tokenStartCharPositionInLine, 
+				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 Token.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/Antlr4.Runtime/LexerNoViableAltException.cs b/Antlr4.Runtime/LexerNoViableAltException.cs
new file mode 100644
index 000000000..198c3ac2e
--- /dev/null
+++ b/Antlr4.Runtime/LexerNoViableAltException.cs
@@ -0,0 +1,86 @@
+/*
+ * [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 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, CharStream input, int startIndex, ATNConfigSet
+			 deadEndConfigs) : base(lexer, input)
+		{
+			this.startIndex = startIndex;
+			this.deadEndConfigs = deadEndConfigs;
+		}
+
+		public virtual int GetStartIndex()
+		{
+			return startIndex;
+		}
+
+		[Nullable]
+		public virtual ATNConfigSet GetDeadEndConfigs()
+		{
+			return deadEndConfigs;
+		}
+
+		public override IntStream GetInputStream()
+		{
+			return (CharStream)base.GetInputStream();
+		}
+
+		public override string ToString()
+		{
+			string symbol = string.Empty;
+			if (startIndex >= 0 && startIndex < ((CharStream)GetInputStream()).Size())
+			{
+				symbol = ((CharStream)GetInputStream()).GetText(Interval.Of(startIndex, startIndex
+					));
+				symbol = Utils.EscapeWhitespace(symbol, false);
+			}
+			return string.Format("%s('%s')", typeof(Antlr4.Runtime.LexerNoViableAltException)
+				.Name, symbol);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/AbstractEqualityComparator.cs b/Antlr4.Runtime/Misc/AbstractEqualityComparator.cs
new file mode 100644
index 000000000..006b7a59d
--- /dev/null
+++ b/Antlr4.Runtime/Misc/AbstractEqualityComparator.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.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// This abstract base class is provided so performance-critical applications can
+	/// use virtual- instead of interface-dispatch when calling comparator methods.
+	/// </summary>
+	/// <remarks>
+	/// This abstract base class is provided so performance-critical applications can
+	/// use virtual- instead of interface-dispatch when calling comparator methods.
+	/// </remarks>
+	/// <author>Sam Harwell</author>
+	public abstract class AbstractEqualityComparator<T> : EqualityComparator<T>
+	{
+		public abstract bool Equals(T arg1, T arg2);
+
+		public abstract int HashCode(T arg1);
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Args.cs b/Antlr4.Runtime/Misc/Args.cs
new file mode 100644
index 000000000..6a594e6a8
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Args.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.
+ */
+using System;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public sealed class Args
+	{
+		/// <exception cref="System.ArgumentNullException">
+		/// if
+		/// <code>value</code>
+		/// is
+		/// <code>null</code>
+		/// .
+		/// </exception>
+		public static void NotNull(string parameterName, object value)
+		{
+			if (value == null)
+			{
+				throw new ArgumentNullException(parameterName + " cannot be null.");
+			}
+		}
+
+		public Args()
+		{
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Array2DHashSet.cs b/Antlr4.Runtime/Misc/Array2DHashSet.cs
new file mode 100644
index 000000000..75d52e40f
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Array2DHashSet.cs
@@ -0,0 +1,692 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// <see cref="Sharpen.Set{E}">Sharpen.Set&lt;E&gt;</see>
+	/// implementation with closed hashing (open addressing).
+	/// </summary>
+	public class Array2DHashSet<T> : ICollection<T>
+	{
+		public const int InitalCapacity = 16;
+
+		public const int InitalBucketCapacity = 8;
+
+		public const double LoadFactor = 0.75;
+
+		[NotNull]
+		protected internal readonly AbstractEqualityComparator<T> comparator;
+
+		protected internal T[][] buckets;
+
+		/// <summary>How many elements in set</summary>
+		protected internal int n = 0;
+
+		protected internal int threshold = (int)(InitalCapacity * LoadFactor);
+
+		protected internal int currentPrime = 1;
+
+		protected internal int initialBucketCapacity = InitalBucketCapacity;
+
+		public Array2DHashSet() : this(null, InitalCapacity, InitalBucketCapacity)
+		{
+		}
+
+		public Array2DHashSet(AbstractEqualityComparator<T> comparator) : this(comparator
+			, InitalCapacity, InitalBucketCapacity)
+		{
+		}
+
+		public Array2DHashSet(AbstractEqualityComparator<T> comparator, int initialCapacity
+			, int initialBucketCapacity)
+		{
+			// must be power of 2
+			// when to expand
+			// jump by 4 primes each expand or whatever
+			if (comparator == null)
+			{
+				comparator = ObjectEqualityComparator.Instance;
+			}
+			this.comparator = comparator;
+			this.buckets = CreateBuckets(initialCapacity);
+			this.initialBucketCapacity = initialBucketCapacity;
+		}
+
+		/// <summary>
+		/// Add
+		/// <code>o</code>
+		/// to set if not there; return existing value if already
+		/// there. This method performs the same operation as
+		/// <see cref="Array2DHashSet{T}.AddItem(object)">Array2DHashSet&lt;T&gt;.AddItem(object)
+		/// 	</see>
+		/// aside from
+		/// the return value.
+		/// </summary>
+		public T GetOrAdd(T o)
+		{
+			if (n > threshold)
+			{
+				Expand();
+			}
+			return GetOrAddImpl(o);
+		}
+
+		protected internal virtual T GetOrAddImpl(T o)
+		{
+			int b = GetBucket(o);
+			T[] bucket = buckets[b];
+			// NEW BUCKET
+			if (bucket == null)
+			{
+				bucket = CreateBucket(initialBucketCapacity);
+				bucket[0] = o;
+				buckets[b] = bucket;
+				n++;
+				return o;
+			}
+			// LOOK FOR IT IN BUCKET
+			for (int i = 0; i < bucket.Length; i++)
+			{
+				T existing = bucket[i];
+				if (existing == null)
+				{
+					// empty slot; not there, add.
+					bucket[i] = o;
+					n++;
+					return o;
+				}
+				if (comparator.Equals(existing, o))
+				{
+					return existing;
+				}
+			}
+			// found existing, quit
+			// FULL BUCKET, expand and add to end
+			int oldLength = bucket.Length;
+			bucket = Arrays.CopyOf(bucket, bucket.Length * 2);
+			buckets[b] = bucket;
+			bucket[oldLength] = o;
+			// add to end
+			n++;
+			return o;
+		}
+
+		public virtual T Get(T o)
+		{
+			if (o == null)
+			{
+				return o;
+			}
+			int b = GetBucket(o);
+			T[] bucket = buckets[b];
+			if (bucket == null)
+			{
+				return null;
+			}
+			// no bucket
+			foreach (T e in bucket)
+			{
+				if (e == null)
+				{
+					return null;
+				}
+				// empty slot; not there
+				if (comparator.Equals(e, o))
+				{
+					return e;
+				}
+			}
+			return null;
+		}
+
+		protected internal int GetBucket(T o)
+		{
+			int hash = comparator.HashCode(o);
+			int b = hash & (buckets.Length - 1);
+			// assumes len is power of 2
+			return b;
+		}
+
+		public override int GetHashCode()
+		{
+			int h = 0;
+			foreach (T[] bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (T o in bucket)
+				{
+					if (o == null)
+					{
+						break;
+					}
+					h += comparator.HashCode(o);
+				}
+			}
+			return h;
+		}
+
+		public override bool Equals(object o)
+		{
+			if (o == this)
+			{
+				return true;
+			}
+			if (!(o is Antlr4.Runtime.Misc.Array2DHashSet))
+			{
+				return false;
+			}
+			Antlr4.Runtime.Misc.Array2DHashSet<object> other = (Antlr4.Runtime.Misc.Array2DHashSet
+				<object>)o;
+			if (other.Count != Count)
+			{
+				return false;
+			}
+			bool same = this.ContainsAll(other);
+			return same;
+		}
+
+		protected internal virtual void Expand()
+		{
+			T[][] old = buckets;
+			currentPrime += 4;
+			int newCapacity = buckets.Length * 2;
+			T[][] newTable = CreateBuckets(newCapacity);
+			int[] newBucketLengths = new int[newTable.Length];
+			buckets = newTable;
+			threshold = (int)(newCapacity * LoadFactor);
+			//		System.out.println("new size="+newCapacity+", thres="+threshold);
+			// rehash all existing entries
+			int oldSize = Count;
+			foreach (T[] bucket in old)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (T o in bucket)
+				{
+					if (o == null)
+					{
+						break;
+					}
+					int b = GetBucket(o);
+					int bucketLength = newBucketLengths[b];
+					T[] newBucket;
+					if (bucketLength == 0)
+					{
+						// new bucket
+						newBucket = CreateBucket(initialBucketCapacity);
+						newTable[b] = newBucket;
+					}
+					else
+					{
+						newBucket = newTable[b];
+						if (bucketLength == newBucket.Length)
+						{
+							// expand
+							newBucket = Arrays.CopyOf(newBucket, newBucket.Length * 2);
+							newTable[b] = newBucket;
+						}
+					}
+					newBucket[bucketLength] = o;
+					newBucketLengths[b]++;
+				}
+			}
+			System.Diagnostics.Debug.Assert(n == oldSize);
+		}
+
+		public bool AddItem(T t)
+		{
+			T existing = GetOrAdd(t);
+			return existing == t;
+		}
+
+		public int Count
+		{
+			get
+			{
+				return n;
+			}
+		}
+
+		public bool IsEmpty()
+		{
+			return n == 0;
+		}
+
+		public bool Contains(object o)
+		{
+			return ContainsFast(AsElementType(o));
+		}
+
+		public virtual bool ContainsFast(T obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			return Get(obj) != null;
+		}
+
+		public virtual IEnumerator<T> GetEnumerator()
+		{
+			return new Array2DHashSet.SetIterator(this, Sharpen.Collections.ToArray(this));
+		}
+
+		public virtual T[] ToArray()
+		{
+			T[] a = CreateBucket(Count);
+			int i = 0;
+			foreach (T[] bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (T o in bucket)
+				{
+					if (o == null)
+					{
+						break;
+					}
+					a[i++] = o;
+				}
+			}
+			return a;
+		}
+
+		public virtual U[] ToArray<U>(U[] a)
+		{
+			if (a.Length < Count)
+			{
+				a = Arrays.CopyOf(a, Count);
+			}
+			int i = 0;
+			foreach (T[] bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (T o in bucket)
+				{
+					if (o == null)
+					{
+						break;
+					}
+					U targetElement = (U)o;
+					// array store will check this
+					a[i++] = targetElement;
+				}
+			}
+			return a;
+		}
+
+		public bool Remove(object o)
+		{
+			return RemoveFast(AsElementType(o));
+		}
+
+		public virtual bool RemoveFast(T obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			int b = GetBucket(obj);
+			T[] bucket = buckets[b];
+			if (bucket == null)
+			{
+				// no bucket
+				return false;
+			}
+			for (int i = 0; i < bucket.Length; i++)
+			{
+				T e = bucket[i];
+				if (e == null)
+				{
+					// empty slot; not there
+					return false;
+				}
+				if (comparator.Equals(e, obj))
+				{
+					// found it
+					// shift all elements to the right down one
+					System.Array.Copy(bucket, i + 1, bucket, i, bucket.Length - i - 1);
+					bucket[bucket.Length - 1] = null;
+					n--;
+					return true;
+				}
+			}
+			return false;
+		}
+
+		public virtual bool ContainsAll<_T0>(ICollection<_T0> collection)
+		{
+			if (collection is Antlr4.Runtime.Misc.Array2DHashSet)
+			{
+				Antlr4.Runtime.Misc.Array2DHashSet<object> s = (Antlr4.Runtime.Misc.Array2DHashSet
+					<object>)collection;
+				foreach (object[] bucket in s.buckets)
+				{
+					if (bucket == null)
+					{
+						continue;
+					}
+					foreach (object o in bucket)
+					{
+						if (o == null)
+						{
+							break;
+						}
+						if (!this.ContainsFast(AsElementType(o)))
+						{
+							return false;
+						}
+					}
+				}
+			}
+			else
+			{
+				foreach (object o in collection)
+				{
+					if (!this.ContainsFast(AsElementType(o)))
+					{
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+
+		public virtual bool AddAll<_T0>(ICollection<_T0> c) where _T0:T
+		{
+			bool changed = false;
+			foreach (T o in c)
+			{
+				T existing = GetOrAdd(o);
+				if (existing != o)
+				{
+					changed = true;
+				}
+			}
+			return changed;
+		}
+
+		public virtual bool RetainAll<_T0>(ICollection<_T0> c)
+		{
+			int newsize = 0;
+			foreach (T[] bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				int i;
+				int j;
+				for (i = 0, j = 0; i < bucket.Length; i++)
+				{
+					if (bucket[i] == null)
+					{
+						break;
+					}
+					if (!c.Contains(bucket[i]))
+					{
+						// removed
+						continue;
+					}
+					// keep
+					if (i != j)
+					{
+						bucket[j] = bucket[i];
+					}
+					j++;
+					newsize++;
+				}
+				newsize += j;
+				while (j < i)
+				{
+					bucket[j] = null;
+					j++;
+				}
+			}
+			bool changed = newsize != n;
+			n = newsize;
+			return changed;
+		}
+
+		public virtual bool RemoveAll<_T0>(ICollection<_T0> c)
+		{
+			bool changed = false;
+			foreach (object o in c)
+			{
+				changed |= RemoveFast(AsElementType(o));
+			}
+			return changed;
+		}
+
+		public virtual void Clear()
+		{
+			buckets = CreateBuckets(InitalCapacity);
+			n = 0;
+		}
+
+		public override string ToString()
+		{
+			if (Count == 0)
+			{
+				return "{}";
+			}
+			StringBuilder buf = new StringBuilder();
+			buf.Append('{');
+			bool first = true;
+			foreach (T[] bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (T o in bucket)
+				{
+					if (o == null)
+					{
+						break;
+					}
+					if (first)
+					{
+						first = false;
+					}
+					else
+					{
+						buf.Append(", ");
+					}
+					buf.Append(o.ToString());
+				}
+			}
+			buf.Append('}');
+			return buf.ToString();
+		}
+
+		public virtual string ToTableString()
+		{
+			StringBuilder buf = new StringBuilder();
+			foreach (T[] bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					buf.Append("null\n");
+					continue;
+				}
+				buf.Append('[');
+				bool first = true;
+				foreach (T o in bucket)
+				{
+					if (first)
+					{
+						first = false;
+					}
+					else
+					{
+						buf.Append(" ");
+					}
+					if (o == null)
+					{
+						buf.Append("_");
+					}
+					else
+					{
+						buf.Append(o.ToString());
+					}
+				}
+				buf.Append("]\n");
+			}
+			return buf.ToString();
+		}
+
+		/// <summary>
+		/// Return
+		/// <code>o</code>
+		/// as an instance of the element type
+		/// <code>T</code>
+		/// . If
+		/// <code>o</code>
+		/// is non-null but known to not be an instance of
+		/// <code>T</code>
+		/// , this
+		/// method returns
+		/// <code>null</code>
+		/// . The base implementation does not perform any
+		/// type checks; override this method to provide strong type checks for the
+		/// <see cref="Array2DHashSet{T}.Contains(object)">Array2DHashSet&lt;T&gt;.Contains(object)
+		/// 	</see>
+		/// and
+		/// <see cref="Array2DHashSet{T}.Remove(object)">Array2DHashSet&lt;T&gt;.Remove(object)
+		/// 	</see>
+		/// methods to ensure the arguments to
+		/// the
+		/// <see cref="EqualityComparator{T}">EqualityComparator&lt;T&gt;</see>
+		/// for the set always have the expected
+		/// types.
+		/// </summary>
+		/// <param name="o">the object to try and cast to the element type of the set</param>
+		/// <returns>
+		/// 
+		/// <code>o</code>
+		/// if it could be an instance of
+		/// <code>T</code>
+		/// , otherwise
+		/// <code>null</code>
+		/// .
+		/// </returns>
+		protected internal virtual T AsElementType(object o)
+		{
+			return (T)o;
+		}
+
+		/// <summary>
+		/// Return an array of
+		/// <code>T[]</code>
+		/// with length
+		/// <code>capacity</code>
+		/// .
+		/// </summary>
+		/// <param name="capacity">the length of the array to return</param>
+		/// <returns>the newly constructed array</returns>
+		protected internal virtual T[][] CreateBuckets(int capacity)
+		{
+			return (T[][])new object[capacity][];
+		}
+
+		/// <summary>
+		/// Return an array of
+		/// <code>T</code>
+		/// with length
+		/// <code>capacity</code>
+		/// .
+		/// </summary>
+		/// <param name="capacity">the length of the array to return</param>
+		/// <returns>the newly constructed array</returns>
+		protected internal virtual T[] CreateBucket(int capacity)
+		{
+			return (T[])new object[capacity];
+		}
+
+		protected internal class SetIterator : IEnumerator<T>
+		{
+			internal readonly T[] data;
+
+			internal int nextIndex = 0;
+
+			internal bool removed = true;
+
+			public SetIterator(Array2DHashSet<T> _enclosing, T[] data)
+			{
+				this._enclosing = _enclosing;
+				this.data = data;
+			}
+
+			public override bool HasNext()
+			{
+				return this.nextIndex < this.data.Length;
+			}
+
+			public override T Next()
+			{
+				if (!this.HasNext())
+				{
+					throw new NoSuchElementException();
+				}
+				this.removed = false;
+				return this.data[this.nextIndex++];
+			}
+
+			public override void Remove()
+			{
+				if (this.removed)
+				{
+					throw new InvalidOperationException();
+				}
+				this._enclosing._enclosing.Remove(this.data[this.nextIndex - 1]);
+				this.removed = true;
+			}
+
+			private readonly Array2DHashSet<T> _enclosing;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/DoubleKeyMap.cs b/Antlr4.Runtime/Misc/DoubleKeyMap.cs
new file mode 100644
index 000000000..6e4e5ef47
--- /dev/null
+++ b/Antlr4.Runtime/Misc/DoubleKeyMap.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.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>Sometimes we need to map a key to a value but key is two pieces of data.
+	/// 	</summary>
+	/// <remarks>
+	/// Sometimes we need to map a key to a value but key is two pieces of data.
+	/// This nested hash table saves creating a single key each time we access
+	/// map; avoids mem creation.
+	/// </remarks>
+	public class DoubleKeyMap<Key1, Key2, Value>
+	{
+		internal IDictionary<Key1, IDictionary<Key2, Value>> data = new LinkedHashMap<Key1
+			, IDictionary<Key2, Value>>();
+
+		public virtual Value Put(Key1 k1, Key2 k2, Value v)
+		{
+			IDictionary<Key2, Value> data2 = data.Get(k1);
+			Value prev = null;
+			if (data2 == null)
+			{
+				data2 = new LinkedHashMap<Key2, Value>();
+				data.Put(k1, data2);
+			}
+			else
+			{
+				prev = data2.Get(k2);
+			}
+			data2.Put(k2, v);
+			return prev;
+		}
+
+		public virtual Value Get(Key1 k1, Key2 k2)
+		{
+			IDictionary<Key2, Value> data2 = data.Get(k1);
+			if (data2 == null)
+			{
+				return null;
+			}
+			return data2.Get(k2);
+		}
+
+		public virtual IDictionary<Key2, Value> Get(Key1 k1)
+		{
+			return data.Get(k1);
+		}
+
+		/// <summary>Get all values associated with primary key</summary>
+		public virtual ICollection<Value> Values(Key1 k1)
+		{
+			IDictionary<Key2, Value> data2 = data.Get(k1);
+			if (data2 == null)
+			{
+				return null;
+			}
+			return data2.Values;
+		}
+
+		/// <summary>get all primary keys</summary>
+		public virtual ICollection<Key1> KeySet()
+		{
+			return data.Keys;
+		}
+
+		/// <summary>get all secondary keys associated with a primary key</summary>
+		public virtual ICollection<Key2> KeySet(Key1 k1)
+		{
+			IDictionary<Key2, Value> data2 = data.Get(k1);
+			if (data2 == null)
+			{
+				return null;
+			}
+			return data2.Keys;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/EqualityComparator.cs b/Antlr4.Runtime/Misc/EqualityComparator.cs
new file mode 100644
index 000000000..2e6262e44
--- /dev/null
+++ b/Antlr4.Runtime/Misc/EqualityComparator.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 Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// This interface provides an abstract concept of object equality independent of
+	/// <see cref="object.Equals(object)">object.Equals(object)</see>
+	/// (object equality) and the
+	/// <code>==</code>
+	/// operator
+	/// (reference equality). It can be used to provide algorithm-specific unordered
+	/// comparisons without requiring changes to the object itself.
+	/// </summary>
+	/// <author>Sam Harwell</author>
+	public interface EqualityComparator<T>
+	{
+		/// <summary>This method returns a hash code for the specified object.</summary>
+		/// <remarks>This method returns a hash code for the specified object.</remarks>
+		/// <param name="obj">The object.</param>
+		/// <returns>
+		/// The hash code for
+		/// <code>obj</code>
+		/// .
+		/// </returns>
+		int HashCode(T obj);
+
+		/// <summary>This method tests if two objects are equal.</summary>
+		/// <remarks>This method tests if two objects are equal.</remarks>
+		/// <param name="a">The first object to compare.</param>
+		/// <param name="b">The second object to compare.</param>
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// if
+		/// <code>a</code>
+		/// equals
+		/// <code>b</code>
+		/// , otherwise
+		/// <code>false</code>
+		/// .
+		/// </returns>
+		bool Equals(T a, T b);
+	}
+}
diff --git a/Antlr4.Runtime/Misc/FlexibleHashMap.cs b/Antlr4.Runtime/Misc/FlexibleHashMap.cs
new file mode 100644
index 000000000..706732a90
--- /dev/null
+++ b/Antlr4.Runtime/Misc/FlexibleHashMap.cs
@@ -0,0 +1,397 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// A limited map (many unsupported operations) that lets me use
+	/// varying hashCode/equals.
+	/// </summary>
+	/// <remarks>
+	/// A limited map (many unsupported operations) that lets me use
+	/// varying hashCode/equals.
+	/// </remarks>
+	public class FlexibleHashMap<K, V> : IDictionary<K, V>
+	{
+		public const int InitalCapacity = 16;
+
+		public const int InitalBucketCapacity = 8;
+
+		public const double LoadFactor = 0.75;
+
+		public class Entry<K, V>
+		{
+			public readonly K key;
+
+			public V value;
+
+			public Entry(K key, V value)
+			{
+				// must be power of 2
+				this.key = key;
+				this.value = value;
+			}
+
+			public override string ToString()
+			{
+				return key.ToString() + ":" + value.ToString();
+			}
+		}
+
+		[NotNull]
+		protected internal readonly AbstractEqualityComparator<K> comparator;
+
+		protected internal List<FlexibleHashMap.Entry<K, V>>[] buckets;
+
+		/// <summary>How many elements in set</summary>
+		protected internal int n = 0;
+
+		protected internal int threshold = (int)(InitalCapacity * LoadFactor);
+
+		protected internal int currentPrime = 1;
+
+		protected internal int initialBucketCapacity = InitalBucketCapacity;
+
+		public FlexibleHashMap() : this(null, InitalCapacity, InitalBucketCapacity)
+		{
+		}
+
+		public FlexibleHashMap(AbstractEqualityComparator<K> comparator) : this(comparator
+			, InitalCapacity, InitalBucketCapacity)
+		{
+		}
+
+		public FlexibleHashMap(AbstractEqualityComparator<K> comparator, int initialCapacity
+			, int initialBucketCapacity)
+		{
+			// when to expand
+			// jump by 4 primes each expand or whatever
+			if (comparator == null)
+			{
+				comparator = ObjectEqualityComparator.Instance;
+			}
+			this.comparator = comparator;
+			this.buckets = CreateEntryListArray(initialBucketCapacity);
+			this.initialBucketCapacity = initialBucketCapacity;
+		}
+
+		private static List<FlexibleHashMap.Entry<K, V>>[] CreateEntryListArray<K, V>(int
+			 length)
+		{
+			List<FlexibleHashMap.Entry<K, V>>[] result = (List<FlexibleHashMap.Entry<K, V>>[]
+				)new List<object>[length];
+			return result;
+		}
+
+		protected internal virtual int GetBucket(K key)
+		{
+			int hash = comparator.HashCode(key);
+			int b = hash & (buckets.Length - 1);
+			// assumes len is power of 2
+			return b;
+		}
+
+		public virtual V Get(object key)
+		{
+			K typedKey = (K)key;
+			if (key == null)
+			{
+				return null;
+			}
+			int b = GetBucket(typedKey);
+			List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
+			if (bucket == null)
+			{
+				return null;
+			}
+			// no bucket
+			foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+			{
+				if (comparator.Equals(e.key, typedKey))
+				{
+					return e.value;
+				}
+			}
+			return null;
+		}
+
+		public virtual V Put(K key, V value)
+		{
+			if (key == null)
+			{
+				return null;
+			}
+			if (n > threshold)
+			{
+				Expand();
+			}
+			int b = GetBucket(key);
+			List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
+			if (bucket == null)
+			{
+				bucket = buckets[b] = new List<FlexibleHashMap.Entry<K, V>>();
+			}
+			foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+			{
+				if (comparator.Equals(e.key, key))
+				{
+					V prev = e.value;
+					e.value = value;
+					n++;
+					return prev;
+				}
+			}
+			// not there
+			bucket.AddItem(new FlexibleHashMap.Entry<K, V>(key, value));
+			n++;
+			return null;
+		}
+
+		public virtual V Remove(object key)
+		{
+			throw new NotSupportedException();
+		}
+
+		public virtual void PutAll<_T0>(IDictionary<_T0> m) where _T0:K
+		{
+			throw new NotSupportedException();
+		}
+
+		public virtual ICollection<K> Keys
+		{
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+		public virtual ICollection<V> Values
+		{
+			get
+			{
+				IList<V> a = new AList<V>(Count);
+				foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+				{
+					if (bucket == null)
+					{
+						continue;
+					}
+					foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+					{
+						a.AddItem(e.value);
+					}
+				}
+				return a;
+			}
+		}
+
+		public virtual ICollection<KeyValuePair<K, V>> EntrySet()
+		{
+			throw new NotSupportedException();
+		}
+
+		public virtual bool ContainsKey(object key)
+		{
+			return Get(key) != null;
+		}
+
+		public virtual bool ContainsValue(object value)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override int GetHashCode()
+		{
+			int h = 0;
+			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+				{
+					if (e == null)
+					{
+						break;
+					}
+					h += comparator.HashCode(e.key);
+				}
+			}
+			return h;
+		}
+
+		public override bool Equals(object o)
+		{
+			throw new NotSupportedException();
+		}
+
+		protected internal virtual void Expand()
+		{
+			List<FlexibleHashMap.Entry<K, V>>[] old = buckets;
+			currentPrime += 4;
+			int newCapacity = buckets.Length * 2;
+			List<FlexibleHashMap.Entry<K, V>>[] newTable = CreateEntryListArray(newCapacity);
+			buckets = newTable;
+			threshold = (int)(newCapacity * LoadFactor);
+			//		System.out.println("new size="+newCapacity+", thres="+threshold);
+			// rehash all existing entries
+			int oldSize = Count;
+			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in old)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+				{
+					if (e == null)
+					{
+						break;
+					}
+					Put(e.key, e.value);
+				}
+			}
+			n = oldSize;
+		}
+
+		public virtual int Count
+		{
+			get
+			{
+				return n;
+			}
+		}
+
+		public virtual bool IsEmpty()
+		{
+			return n == 0;
+		}
+
+		public virtual void Clear()
+		{
+			buckets = CreateEntryListArray(InitalCapacity);
+			n = 0;
+		}
+
+		public override string ToString()
+		{
+			if (Count == 0)
+			{
+				return "{}";
+			}
+			StringBuilder buf = new StringBuilder();
+			buf.Append('{');
+			bool first = true;
+			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					continue;
+				}
+				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+				{
+					if (e == null)
+					{
+						break;
+					}
+					if (first)
+					{
+						first = false;
+					}
+					else
+					{
+						buf.Append(", ");
+					}
+					buf.Append(e.ToString());
+				}
+			}
+			buf.Append('}');
+			return buf.ToString();
+		}
+
+		public virtual string ToTableString()
+		{
+			StringBuilder buf = new StringBuilder();
+			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+			{
+				if (bucket == null)
+				{
+					buf.Append("null\n");
+					continue;
+				}
+				buf.Append('[');
+				bool first = true;
+				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+				{
+					if (first)
+					{
+						first = false;
+					}
+					else
+					{
+						buf.Append(" ");
+					}
+					if (e == null)
+					{
+						buf.Append("_");
+					}
+					else
+					{
+						buf.Append(e.ToString());
+					}
+				}
+				buf.Append("]\n");
+			}
+			return buf.ToString();
+		}
+
+		public static void Main(string[] args)
+		{
+			FlexibleHashMap<string, int> map = new FlexibleHashMap<string, int>();
+			map.Put("hi", 1);
+			map.Put("mom", 2);
+			map.Put("foo", 3);
+			map.Put("ach", 4);
+			map.Put("cbba", 5);
+			map.Put("d", 6);
+			map.Put("edf", 7);
+			map.Put("mom", 8);
+			map.Put("hi", 9);
+			System.Console.Out.WriteLine(map);
+			System.Console.Out.WriteLine(map.ToTableString());
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Func0.cs b/Antlr4.Runtime/Misc/Func0.cs
new file mode 100644
index 000000000..82a100be6
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Func0.cs
@@ -0,0 +1,40 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public interface Func0<Result>
+	{
+		Result Eval();
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Func1.cs b/Antlr4.Runtime/Misc/Func1.cs
new file mode 100644
index 000000000..99cb27e3c
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Func1.cs
@@ -0,0 +1,40 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public interface Func1<T1, Result>
+	{
+		Result Eval(T1 arg1);
+	}
+}
diff --git a/Antlr4.Runtime/Misc/IntSet.cs b/Antlr4.Runtime/Misc/IntSet.cs
new file mode 100644
index 000000000..e51c9f899
--- /dev/null
+++ b/Antlr4.Runtime/Misc/IntSet.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.
+ */
+using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>A generic set of ints.</summary>
+	/// <remarks>A generic set of ints.</remarks>
+	/// <seealso cref="IntervalSet">IntervalSet</seealso>
+	public interface IntSet
+	{
+		/// <summary>Add an element to the set</summary>
+		void Add(int el);
+
+		/// <summary>Add all elements from incoming set to this set.</summary>
+		/// <remarks>
+		/// Add all elements from incoming set to this set.  Can limit
+		/// to set of its own type. Return "this" so we can chain calls.
+		/// </remarks>
+		IntSet AddAll(IntSet set);
+
+		/// <summary>
+		/// Return the intersection of this set with the argument, creating
+		/// a new set.
+		/// </summary>
+		/// <remarks>
+		/// Return the intersection of this set with the argument, creating
+		/// a new set.
+		/// </remarks>
+		IntSet And(IntSet a);
+
+		IntSet Complement(IntSet elements);
+
+		IntSet Or(IntSet a);
+
+		IntSet Subtract(IntSet a);
+
+		/// <summary>
+		/// Return the size of this set (not the underlying implementation's
+		/// allocated memory size, for example).
+		/// </summary>
+		/// <remarks>
+		/// Return the size of this set (not the underlying implementation's
+		/// allocated memory size, for example).
+		/// </remarks>
+		int Size();
+
+		bool IsNil();
+
+		bool Equals(object obj);
+
+		int GetSingleElement();
+
+		bool Contains(int el);
+
+		/// <summary>remove this element from this set</summary>
+		void Remove(int el);
+
+		IList<int> ToList();
+
+		string ToString();
+	}
+}
diff --git a/Antlr4.Runtime/Misc/IntegerList.cs b/Antlr4.Runtime/Misc/IntegerList.cs
new file mode 100644
index 000000000..a9fe4598c
--- /dev/null
+++ b/Antlr4.Runtime/Misc/IntegerList.cs
@@ -0,0 +1,346 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public class IntegerList
+	{
+		private static int[] EmptyData = new int[0];
+
+		private const int InitialSize = 4;
+
+		private const int MaxArraySize = int.MaxValue - 8;
+
+		[NotNull]
+		private int[] _data;
+
+		private int _size;
+
+		public IntegerList()
+		{
+			_data = EmptyData;
+		}
+
+		public IntegerList(int capacity)
+		{
+			if (capacity < 0)
+			{
+				throw new ArgumentException();
+			}
+			if (capacity == 0)
+			{
+				_data = EmptyData;
+			}
+			else
+			{
+				_data = new int[capacity];
+			}
+		}
+
+		public IntegerList(Antlr4.Runtime.Misc.IntegerList list)
+		{
+			_data = list._data.Clone();
+			_size = list._size;
+		}
+
+		public IntegerList(ICollection<int> list) : this(list.Count)
+		{
+			foreach (int value in list)
+			{
+				Add(value);
+			}
+		}
+
+		public void Add(int value)
+		{
+			if (_data.Length == _size)
+			{
+				EnsureCapacity(_size + 1);
+			}
+			_data[_size] = value;
+			_size++;
+		}
+
+		public void AddAll(int[] array)
+		{
+			EnsureCapacity(_size + array.Length);
+			System.Array.Copy(array, 0, _data, _size, array.Length);
+			_size += array.Length;
+		}
+
+		public void AddAll(Antlr4.Runtime.Misc.IntegerList list)
+		{
+			EnsureCapacity(_size + list._size);
+			System.Array.Copy(list._data, 0, _data, _size, list._size);
+			_size += list._size;
+		}
+
+		public void AddAll(ICollection<int> list)
+		{
+			EnsureCapacity(_size + list.Count);
+			int current = 0;
+			foreach (int x in list)
+			{
+				_data[_size + current] = x;
+			}
+			_size += list.Count;
+		}
+
+		public int Get(int index)
+		{
+			if (index < 0 || index >= _size)
+			{
+				throw new IndexOutOfRangeException();
+			}
+			return _data[index];
+		}
+
+		public bool Contains(int value)
+		{
+			for (int i = 0; i < _size; i++)
+			{
+				if (_data[i] == value)
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		public int Set(int index, int value)
+		{
+			if (index < 0 || index >= _size)
+			{
+				throw new IndexOutOfRangeException();
+			}
+			int previous = _data[index];
+			_data[index] = value;
+			return previous;
+		}
+
+		public int RemoveAt(int index)
+		{
+			int value = Get(index);
+			System.Array.Copy(_data, index + 1, _data, index, _size - index - 1);
+			_data[_size - 1] = 0;
+			_size--;
+			return value;
+		}
+
+		public void RemoveRange(int fromIndex, int toIndex)
+		{
+			if (fromIndex < 0 || toIndex < 0 || fromIndex > _size || toIndex > _size)
+			{
+				throw new IndexOutOfRangeException();
+			}
+			if (fromIndex > toIndex)
+			{
+				throw new ArgumentException();
+			}
+			System.Array.Copy(_data, toIndex, _data, fromIndex, _size - toIndex);
+			Arrays.Fill(_data, _size - (toIndex - fromIndex), _size, 0);
+			_size -= (toIndex - fromIndex);
+		}
+
+		public bool IsEmpty()
+		{
+			return _size == 0;
+		}
+
+		public int Size()
+		{
+			return _size;
+		}
+
+		public void TrimToSize()
+		{
+			if (_data.Length == _size)
+			{
+				return;
+			}
+			_data = Arrays.CopyOf(_data, _size);
+		}
+
+		public void Clear()
+		{
+			Arrays.Fill(_data, 0, _size, 0);
+			_size = 0;
+		}
+
+		public int[] ToArray()
+		{
+			if (_size == 0)
+			{
+				return EmptyData;
+			}
+			return Arrays.CopyOf(_data, _size);
+		}
+
+		public void Sort()
+		{
+			Arrays.Sort(_data, 0, _size);
+		}
+
+		/// <summary>Compares the specified object with this list for equality.</summary>
+		/// <remarks>
+		/// Compares the specified object with this list for equality.  Returns
+		/// <code>true</code>
+		/// if and only if the specified object is also an
+		/// <see cref="IntegerList">IntegerList</see>
+		/// ,
+		/// both lists have the same size, and all corresponding pairs of elements in
+		/// the two lists are equal.  In other words, two lists are defined to be
+		/// equal if they contain the same elements in the same order.
+		/// <p>
+		/// This implementation first checks if the specified object is this
+		/// list. If so, it returns
+		/// <code>true</code>
+		/// ; if not, it checks if the
+		/// specified object is an
+		/// <see cref="IntegerList">IntegerList</see>
+		/// . If not, it returns
+		/// <code>false</code>
+		/// ;
+		/// if so, it checks the size of both lists. If the lists are not the same size,
+		/// it returns
+		/// <code>false</code>
+		/// ; otherwise it iterates over both lists, comparing
+		/// corresponding pairs of elements.  If any comparison returns
+		/// <code>false</code>
+		/// ,
+		/// this method returns
+		/// <code>false</code>
+		/// .
+		/// </remarks>
+		/// <param name="o">the object to be compared for equality with this list</param>
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// if the specified object is equal to this list
+		/// </returns>
+		public override bool Equals(object o)
+		{
+			if (o == this)
+			{
+				return true;
+			}
+			if (!(o is Antlr4.Runtime.Misc.IntegerList))
+			{
+				return false;
+			}
+			Antlr4.Runtime.Misc.IntegerList other = (Antlr4.Runtime.Misc.IntegerList)o;
+			if (_size != other._size)
+			{
+				return false;
+			}
+			for (int i = 0; i < _size; i++)
+			{
+				if (_data[i] != other._data[i])
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+
+		/// <summary>Returns the hash code value for this list.</summary>
+		/// <remarks>
+		/// Returns the hash code value for this list.
+		/// <p/>
+		/// This implementation uses exactly the code that is used to define the
+		/// list hash function in the documentation for the
+		/// <see cref="System.Collections.IList{E}.GetHashCode()">System.Collections.IList&lt;E&gt;.GetHashCode()
+		/// 	</see>
+		/// method.
+		/// </remarks>
+		/// <returns>the hash code value for this list</returns>
+		public override int GetHashCode()
+		{
+			int hashCode = 1;
+			for (int i = 0; i < _size; i++)
+			{
+				hashCode = 31 * hashCode + _data[i];
+			}
+			return hashCode;
+		}
+
+		/// <summary>Returns a string representation of this list.</summary>
+		/// <remarks>Returns a string representation of this list.</remarks>
+		public override string ToString()
+		{
+			return Arrays.ToString(ToArray());
+		}
+
+		public int BinarySearch(int key)
+		{
+			return System.Array.BinarySearch(_data, 0, _size, key);
+		}
+
+		public int BinarySearch(int fromIndex, int toIndex, int key)
+		{
+			if (fromIndex < 0 || toIndex < 0 || fromIndex > _size || toIndex > _size)
+			{
+				throw new IndexOutOfRangeException();
+			}
+			return System.Array.BinarySearch(_data, fromIndex, toIndex, key);
+		}
+
+		private void EnsureCapacity(int capacity)
+		{
+			if (capacity < 0 || capacity > MaxArraySize)
+			{
+				throw new OutOfMemoryException();
+			}
+			int newLength;
+			if (_data.Length == 0)
+			{
+				newLength = InitialSize;
+			}
+			else
+			{
+				newLength = _data.Length;
+			}
+			while (newLength < capacity)
+			{
+				newLength = newLength * 2;
+				if (newLength < 0 || newLength > MaxArraySize)
+				{
+					newLength = MaxArraySize;
+				}
+			}
+			_data = Arrays.CopyOf(_data, newLength);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/IntegerStack.cs b/Antlr4.Runtime/Misc/IntegerStack.cs
new file mode 100644
index 000000000..ee5ad07cf
--- /dev/null
+++ b/Antlr4.Runtime/Misc/IntegerStack.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 Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public class IntegerStack : IntegerList
+	{
+		public IntegerStack()
+		{
+		}
+
+		public IntegerStack(int capacity) : base(capacity)
+		{
+		}
+
+		public IntegerStack(Antlr4.Runtime.Misc.IntegerStack list) : base(list)
+		{
+		}
+
+		public void Push(int value)
+		{
+			Add(value);
+		}
+
+		public int Pop()
+		{
+			return RemoveAt(Size() - 1);
+		}
+
+		public int Peek()
+		{
+			return Get(Size() - 1);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Interval.cs b/Antlr4.Runtime/Misc/Interval.cs
new file mode 100644
index 000000000..2308206ef
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Interval.cs
@@ -0,0 +1,226 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>An immutable inclusive interval a..b</summary>
+	public class Interval
+	{
+		public const int IntervalPoolMaxValue = 1000;
+
+		public static readonly Antlr4.Runtime.Misc.Interval Invalid = new Antlr4.Runtime.Misc.Interval
+			(-1, -2);
+
+		private static Antlr4.Runtime.Misc.Interval[] cache = new Antlr4.Runtime.Misc.Interval
+			[IntervalPoolMaxValue + 1];
+
+		/// <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)
+		{
+			// cache just a..a
+			if (a != b || a < 0 || a > IntervalPoolMaxValue)
+			{
+				return new Antlr4.Runtime.Misc.Interval(a, b);
+			}
+			if (cache[a] == null)
+			{
+				cache[a] = new Antlr4.Runtime.Misc.Interval(a, a);
+			}
+			return cache[a];
+		}
+
+		/// <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 virtual int Length()
+		{
+			if (b < a)
+			{
+				return 0;
+			}
+			return b - a + 1;
+		}
+
+		public override bool Equals(object o)
+		{
+			if (o == this)
+			{
+				return true;
+			}
+			else
+			{
+				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 = 5;
+			hash = 37 * hash ^ this.a;
+			hash = 37 * hash ^ this.b;
+			return hash;
+		}
+
+		/// <summary>Does this start completely before other? Disjoint</summary>
+		public virtual 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 virtual 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 virtual bool StartsAfter(Antlr4.Runtime.Misc.Interval other)
+		{
+			return this.a > other.a;
+		}
+
+		/// <summary>Does this start completely after other? Disjoint</summary>
+		public virtual bool StartsAfterDisjoint(Antlr4.Runtime.Misc.Interval other)
+		{
+			return this.a > other.b;
+		}
+
+		/// <summary>Does this start after other? NonDisjoint</summary>
+		public virtual 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 virtual 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 virtual bool Adjacent(Antlr4.Runtime.Misc.Interval other)
+		{
+			return this.a == other.b + 1 || this.b == other.a - 1;
+		}
+
+		public virtual 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 virtual 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 virtual 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
+		/// <code>this</code>
+		/// not in
+		/// <code>other</code>
+		/// ;
+		/// <code>other</code>
+		/// must not be totally enclosed (properly contained)
+		/// within
+		/// <code>this</code>
+		/// , which would result in two disjoint intervals
+		/// instead of the single one returned by this method.
+		/// </summary>
+		public virtual 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/Antlr4.Runtime/Misc/IntervalSet.cs b/Antlr4.Runtime/Misc/IntervalSet.cs
new file mode 100644
index 000000000..7fe2cd04c
--- /dev/null
+++ b/Antlr4.Runtime/Misc/IntervalSet.cs
@@ -0,0 +1,821 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// 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).
+	/// </summary>
+	/// <remarks>
+	/// 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.
+	/// 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.
+	/// </remarks>
+	public class IntervalSet : IntSet
+	{
+		public static readonly Antlr4.Runtime.Misc.IntervalSet CompleteCharSet = Antlr4.Runtime.Misc.IntervalSet
+			.Of(0, Lexer.MaxCharValue);
+
+		public static readonly Antlr4.Runtime.Misc.IntervalSet EmptySet = new Antlr4.Runtime.Misc.IntervalSet
+			();
+
+		/// <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 AList<Interval>(2);
+			}
+			else
+			{
+				// most sets are 1 or 2 elements
+				intervals = new AList<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>
+		[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 (ListIterator<Interval> iter = intervals.ListIterator(); iter.HasNext(); )
+			{
+				Interval r = iter.Next();
+				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);
+					iter.Set(bigger);
+					// make sure we didn't just create an interval that
+					// should be merged with next interval in list
+					if (iter.HasNext())
+					{
+						Interval next = iter.Next();
+						if (bigger.Adjacent(next) || !bigger.Disjoint(next))
+						{
+							// if we bump up against or overlap next, merge
+							iter.Remove();
+							// remove this one
+							iter.Previous();
+							// move backwards to what we just set
+							iter.Set(bigger.Union(next));
+						}
+					}
+					// set to 3 merged ones
+					return;
+				}
+				if (addition.StartsBeforeDisjoint(r))
+				{
+					// insert before r
+					iter.Previous();
+					iter.Add(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.AddItem(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(IntSet set)
+		{
+			if (set == null)
+			{
+				return this;
+			}
+			if (!(set is Antlr4.Runtime.Misc.IntervalSet))
+			{
+				throw new ArgumentException("can't add non IntSet (" + set.GetType().FullName + ") to 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);
+			}
+			return this;
+		}
+
+		public virtual Antlr4.Runtime.Misc.IntervalSet Complement(int minElement, int maxElement
+			)
+		{
+			return this.Complement(Antlr4.Runtime.Misc.IntervalSet.Of(minElement, maxElement)
+				);
+		}
+
+		/// <summary>
+		/// 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.
+		/// </summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		public virtual Antlr4.Runtime.Misc.IntervalSet Complement(IntSet vocabulary)
+		{
+			if (vocabulary == null)
+			{
+				return null;
+			}
+			// nothing in common with null set
+			if (!(vocabulary is Antlr4.Runtime.Misc.IntervalSet))
+			{
+				throw new ArgumentException("can't complement with non IntervalSet (" + vocabulary
+					.GetType().FullName + ")");
+			}
+			Antlr4.Runtime.Misc.IntervalSet vocabularyIS = ((Antlr4.Runtime.Misc.IntervalSet)
+				vocabulary);
+			int maxElement = vocabularyIS.GetMaxElement();
+			Antlr4.Runtime.Misc.IntervalSet compl = new Antlr4.Runtime.Misc.IntervalSet();
+			int n = intervals.Count;
+			if (n == 0)
+			{
+				return compl;
+			}
+			Interval first = intervals[0];
+			// add a range from 0 to first.a constrained to vocab
+			if (first.a > 0)
+			{
+				Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(0, first.a
+					 - 1);
+				Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
+				compl.AddAll(a);
+			}
+			for (int i = 1; i < n; i++)
+			{
+				// from 2nd interval .. nth
+				Interval previous = intervals[i - 1];
+				Interval current = intervals[i];
+				Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(previous.b
+					 + 1, current.a - 1);
+				Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
+				compl.AddAll(a);
+			}
+			Interval last = intervals[n - 1];
+			// add a range from last.b to maxElement constrained to vocab
+			if (last.b < maxElement)
+			{
+				Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(last.b + 1
+					, maxElement);
+				Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
+				compl.AddAll(a);
+			}
+			return compl;
+		}
+
+		/// <summary>Compute this-other via this&~other.</summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		public virtual Antlr4.Runtime.Misc.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(((Antlr4.Runtime.Misc.IntervalSet)other).Complement(CompleteCharSet
+				));
+		}
+
+		public virtual Antlr4.Runtime.Misc.IntervalSet Or(IntSet a)
+		{
+			Antlr4.Runtime.Misc.IntervalSet o = new Antlr4.Runtime.Misc.IntervalSet();
+			o.AddAll(this);
+			o.AddAll(a);
+			return o;
+		}
+
+		/// <summary>Return a new set with the intersection of this set with other.</summary>
+		/// <remarks>
+		/// 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.
+		/// </remarks>
+		public virtual Antlr4.Runtime.Misc.IntervalSet And(IntSet 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>Is el in any range of this set?</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>return true if this set has no members</summary>
+		public virtual bool IsNil()
+		{
+			return intervals == null || intervals.IsEmpty();
+		}
+
+		/// <summary>If this set is a single integer, return it otherwise Token.INVALID_TYPE</summary>
+		public virtual int GetSingleElement()
+		{
+			if (intervals != null && intervals.Count == 1)
+			{
+				Interval I = intervals[0];
+				if (I.a == I.b)
+				{
+					return I.a;
+				}
+			}
+			return Token.InvalidType;
+		}
+
+		public virtual int GetMaxElement()
+		{
+			if (IsNil())
+			{
+				return Token.InvalidType;
+			}
+			Interval last = intervals[intervals.Count - 1];
+			return last.b;
+		}
+
+		/// <summary>Return minimum element &gt;= 0</summary>
+		public virtual int GetMinElement()
+		{
+			if (IsNil())
+			{
+				return Token.InvalidType;
+			}
+			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++)
+				{
+					if (v >= 0)
+					{
+						return v;
+					}
+				}
+			}
+			return Token.InvalidType;
+		}
+
+		/// <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()
+		{
+			if (IsNil())
+			{
+				return 0;
+			}
+			int n = 0;
+			// just add left edge of intervals
+			foreach (Interval I in intervals)
+			{
+				n += I.a;
+			}
+			return n;
+		}
+
+		/// <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.Equals(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.IsEmpty())
+			{
+				return "{}";
+			}
+			if (this.Size() > 1)
+			{
+				buf.Append("{");
+			}
+			IEnumerator<Interval> iter = this.intervals.GetEnumerator();
+			while (iter.HasNext())
+			{
+				Interval I = iter.Next();
+				int a = I.a;
+				int b = I.b;
+				if (a == b)
+				{
+					if (a == -1)
+					{
+						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 (iter.HasNext())
+				{
+					buf.Append(", ");
+				}
+			}
+			if (this.Size() > 1)
+			{
+				buf.Append("}");
+			}
+			return buf.ToString();
+		}
+
+		public virtual string ToString(string[] tokenNames)
+		{
+			StringBuilder buf = new StringBuilder();
+			if (this.intervals == null || this.intervals.IsEmpty())
+			{
+				return "{}";
+			}
+			if (this.Size() > 1)
+			{
+				buf.Append("{");
+			}
+			IEnumerator<Interval> iter = this.intervals.GetEnumerator();
+			while (iter.HasNext())
+			{
+				Interval I = iter.Next();
+				int a = I.a;
+				int b = I.b;
+				if (a == b)
+				{
+					buf.Append(ElementName(tokenNames, a));
+				}
+				else
+				{
+					for (int i = a; i <= b; i++)
+					{
+						if (i > a)
+						{
+							buf.Append(", ");
+						}
+						buf.Append(ElementName(tokenNames, i));
+					}
+				}
+				if (iter.HasNext())
+				{
+					buf.Append(", ");
+				}
+			}
+			if (this.Size() > 1)
+			{
+				buf.Append("}");
+			}
+			return buf.ToString();
+		}
+
+		protected internal virtual string ElementName(string[] tokenNames, int a)
+		{
+			if (a == Token.Eof)
+			{
+				return "<EOF>";
+			}
+			else
+			{
+				if (a == Token.Epsilon)
+				{
+					return "<EPSILON>";
+				}
+				else
+				{
+					return tokenNames[a];
+				}
+			}
+		}
+
+		public virtual int Size()
+		{
+			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 IntegerList ToIntegerList()
+		{
+			IntegerList values = new IntegerList(Size());
+			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 AList<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.AddItem(v);
+				}
+			}
+			return values;
+		}
+
+		public virtual ICollection<int> ToSet()
+		{
+			ICollection<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.AddItem(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.Remove(i);
+					break;
+				}
+				// if on left edge x..b, adjust left
+				if (el == a)
+				{
+					intervals.Set(i, Interval.Of(I.a + 1, I.b));
+					break;
+				}
+				// if on right edge a..x, adjust right
+				if (el == b)
+				{
+					intervals.Set(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.Set(i, Interval.Of(I.a, el - 1));
+					// [a..x-1]
+					Add(el + 1, oldb);
+				}
+			}
+		}
+
+		// add [x+1..b]
+		public virtual bool IsReadonly()
+		{
+			return @readonly;
+		}
+
+		public virtual void SetReadonly(bool @readonly)
+		{
+			this.@readonly = @readonly;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/MultiMap.cs b/Antlr4.Runtime/Misc/MultiMap.cs
new file mode 100644
index 000000000..cdec395fc
--- /dev/null
+++ b/Antlr4.Runtime/Misc/MultiMap.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;
+using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	[System.Serializable]
+	public class MultiMap<K, V> : LinkedHashMap<K, IList<V>>
+	{
+		private const long serialVersionUID = -4956746660057462312L;
+
+		public virtual void Map(K key, V value)
+		{
+			IList<V> elementsForKey = Get(key);
+			if (elementsForKey == null)
+			{
+				elementsForKey = new AList<V>();
+				base.Put(key, elementsForKey);
+			}
+			elementsForKey.AddItem(value);
+		}
+
+		public virtual IList<Tuple<K, V>> GetPairs()
+		{
+			IList<Tuple<K, V>> pairs = new AList<Tuple<K, V>>();
+			foreach (K key in Keys)
+			{
+				foreach (V value in Get(key))
+				{
+					pairs.AddItem(Tuple.Create(key, value));
+				}
+			}
+			return pairs;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs b/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
new file mode 100644
index 000000000..080c77667
--- /dev/null
+++ b/Antlr4.Runtime/Misc/ObjectEqualityComparator.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.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// This default implementation of
+	/// <see cref="EqualityComparator{T}">EqualityComparator&lt;T&gt;</see>
+	/// uses object equality
+	/// for comparisons by calling
+	/// <see cref="object.GetHashCode()">object.GetHashCode()</see>
+	/// and
+	/// <see cref="object.Equals(object)">object.Equals(object)</see>
+	/// .
+	/// </summary>
+	/// <author>Sam Harwell</author>
+	public sealed class ObjectEqualityComparator : AbstractEqualityComparator<object>
+	{
+		public static readonly ObjectEqualityComparator Instance = new ObjectEqualityComparator
+			();
+
+		/// <summary>
+		/// <inheritDoc></inheritDoc>
+		/// <p/>
+		/// This implementation returns
+		/// <code>obj.</code>
+		/// <see cref="object.GetHashCode()">hashCode()</see>
+		/// .
+		/// </summary>
+		public override int HashCode(object obj)
+		{
+			if (obj == null)
+			{
+				return 0;
+			}
+			return obj.GetHashCode();
+		}
+
+		/// <summary>
+		/// <inheritDoc></inheritDoc>
+		/// <p/>
+		/// This implementation relies on object equality. If both objects are
+		/// <code>null</code>
+		/// , this method returns
+		/// <code>true</code>
+		/// . Otherwise if only
+		/// <code>a</code>
+		/// is
+		/// <code>null</code>
+		/// , this method returns
+		/// <code>false</code>
+		/// . Otherwise,
+		/// this method returns the result of
+		/// <code>a.</code>
+		/// <see cref="object.Equals(object)">equals</see>
+		/// <code>(b)</code>
+		/// .
+		/// </summary>
+		public override bool Equals(object a, object b)
+		{
+			if (a == null)
+			{
+				return b == null;
+			}
+			return a.Equals(b);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/OrderedHashSet.cs b/Antlr4.Runtime/Misc/OrderedHashSet.cs
new file mode 100644
index 000000000..eb0a1f16b
--- /dev/null
+++ b/Antlr4.Runtime/Misc/OrderedHashSet.cs
@@ -0,0 +1,164 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>A HashMap that remembers the order that the elements were added.</summary>
+	/// <remarks>
+	/// A HashMap that remembers the order that the elements were added.
+	/// You can alter the ith element with set(i,value) too :)  Unique list.
+	/// I need the replace/set-element-i functionality so I'm subclassing
+	/// LinkedHashSet.
+	/// </remarks>
+	[System.Serializable]
+	public class OrderedHashSet<T> : LinkedHashSet<T>
+	{
+		private const long serialVersionUID = 5281944403755906761L;
+
+		/// <summary>Track the elements as they are added to the set</summary>
+		protected internal AList<T> elements = new AList<T>();
+
+		public virtual T Get(int i)
+		{
+			return elements[i];
+		}
+
+		/// <summary>
+		/// Replace an existing value with a new value; updates the element
+		/// list and the hash table, but not the key as that has not changed.
+		/// </summary>
+		/// <remarks>
+		/// Replace an existing value with a new value; updates the element
+		/// list and the hash table, but not the key as that has not changed.
+		/// </remarks>
+		public virtual T Set(int i, T value)
+		{
+			T oldElement = elements[i];
+			elements.Set(i, value);
+			// update list
+			base.Remove(oldElement);
+			// now update the set: remove/add
+			base.AddItem(value);
+			return oldElement;
+		}
+
+		public virtual bool Remove(int i)
+		{
+			T o = elements.Remove(i);
+			return base.Remove(o);
+		}
+
+		/// <summary>
+		/// Add a value to list; keep in hashtable for consistency also;
+		/// Key is object itself.
+		/// </summary>
+		/// <remarks>
+		/// Add a value to list; keep in hashtable for consistency also;
+		/// Key is object itself.  Good for say asking if a certain string is in
+		/// a list of strings.
+		/// </remarks>
+		public override bool AddItem(T value)
+		{
+			bool result = base.AddItem(value);
+			if (result)
+			{
+				// only track if new element not in set
+				elements.AddItem(value);
+			}
+			return result;
+		}
+
+		public override bool Remove(object o)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void Clear()
+		{
+			elements.Clear();
+			base.Clear();
+		}
+
+		public override int GetHashCode()
+		{
+			return elements.GetHashCode();
+		}
+
+		public override bool Equals(object o)
+		{
+			if (!(o is OrderedHashSet<object>))
+			{
+				return false;
+			}
+			//		System.out.print("equals " + this + ", " + o+" = ");
+			bool same = elements != null && elements.Equals(((OrderedHashSet<object>)o).elements
+				);
+			//		System.out.println(same);
+			return same;
+		}
+
+		public override IEnumerator<T> GetEnumerator()
+		{
+			return elements.GetEnumerator();
+		}
+
+		/// <summary>Return the List holding list of table elements.</summary>
+		/// <remarks>
+		/// Return the List holding list of table elements.  Note that you are
+		/// NOT getting a copy so don't write to the list.
+		/// </remarks>
+		public virtual IList<T> Elements()
+		{
+			return elements;
+		}
+
+		public override object Clone()
+		{
+			OrderedHashSet<T> dup = (OrderedHashSet<T>)base.Clone();
+			// safe (result of clone)
+			dup.elements = new AList<T>(this.elements);
+			return dup;
+		}
+
+		public override object[] ToArray()
+		{
+			return Sharpen.Collections.ToArray(elements);
+		}
+
+		public override string ToString()
+		{
+			return elements.ToString();
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/ParseCanceledException.cs b/Antlr4.Runtime/Misc/ParseCanceledException.cs
new file mode 100644
index 000000000..60a16df84
--- /dev/null
+++ b/Antlr4.Runtime/Misc/ParseCanceledException.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;
+using Sharpen;
+
+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">Antlr4.Runtime.RecognitionException
+	/// 	</see>
+	/// , allowing it to bypass the standard
+	/// error recovery mechanisms.
+	/// <see cref="Antlr4.Runtime.BailErrorStrategy">Antlr4.Runtime.BailErrorStrategy</see>
+	/// throws this exception in
+	/// response to a parse error.
+	/// </remarks>
+	/// <author>Sam Harwell</author>
+	[System.Serializable]
+	public class ParseCanceledException : OperationCanceledException
+	{
+		private const long serialVersionUID = -3529552099366979683L;
+
+		public ParseCanceledException()
+		{
+		}
+
+		public ParseCanceledException(string message) : base(message)
+		{
+		}
+
+		public ParseCanceledException(Exception cause)
+		{
+			Sharpen.Extensions.InitCause(this, cause);
+		}
+
+		public ParseCanceledException(string message, Exception cause) : base(message)
+		{
+			Sharpen.Extensions.InitCause(this, cause);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Predicate.cs b/Antlr4.Runtime/Misc/Predicate.cs
new file mode 100644
index 000000000..6a326b57c
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Predicate.cs
@@ -0,0 +1,40 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public interface Predicate<T>
+	{
+		bool Eval(T arg);
+	}
+}
diff --git a/Antlr4.Runtime/Misc/RuleDependencyChecker.cs b/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
new file mode 100644
index 000000000..938e403b3
--- /dev/null
+++ b/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
@@ -0,0 +1,327 @@
+/*
+ * [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.Reflection;
+using System.Security;
+using System.Text;
+using Antlr4.Runtime;
+using Sharpen;
+using Sharpen.Annotation;
+using Sharpen.Logging;
+using Sharpen.Reflect;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public class RuleDependencyChecker
+	{
+		private static readonly Logger Logger = Logger.GetLogger(typeof(Antlr4.Runtime.Misc.RuleDependencyChecker
+			).FullName);
+
+		private static readonly ICollection<Type> checkedTypes = new HashSet<Type>();
+
+		public static void CheckDependencies<_T0>(Type<_T0> dependentClass)
+		{
+			if (IsChecked(dependentClass))
+			{
+				return;
+			}
+			IList<Type> typesToCheck = new AList<Type>();
+			typesToCheck.AddItem(dependentClass);
+			Sharpen.Collections.AddAll(typesToCheck, dependentClass.GetDeclaredClasses());
+			foreach (Type clazz in typesToCheck)
+			{
+				if (IsChecked(clazz))
+				{
+					continue;
+				}
+				IList<Tuple<RuleDependency, AnnotatedElement>> dependencies = GetDependencies(clazz
+					);
+				if (dependencies.IsEmpty())
+				{
+					continue;
+				}
+				CheckDependencies(dependencies, dependencies[0].GetItem1().Recognizer());
+			}
+		}
+
+		private static bool IsChecked<_T0>(Type<_T0> clazz)
+		{
+			lock (checkedTypes)
+			{
+				return checkedTypes.Contains(clazz);
+			}
+		}
+
+		private static void MarkChecked<_T0>(Type<_T0> clazz)
+		{
+			lock (checkedTypes)
+			{
+				checkedTypes.AddItem(clazz);
+			}
+		}
+
+		private static void CheckDependencies<_T0>(IList<Tuple<RuleDependency, AnnotatedElement
+			>> dependencies, Type<_T0> recognizerClass) where _T0:Recognizer<object, object>
+		{
+			string[] ruleNames = GetRuleNames(recognizerClass);
+			int[] ruleVersions = GetRuleVersions(recognizerClass, ruleNames);
+			StringBuilder incompatible = new StringBuilder();
+			foreach (Tuple<RuleDependency, AnnotatedElement> dependency in dependencies)
+			{
+				if (!recognizerClass.IsAssignableFrom(dependency.GetItem1().Recognizer()))
+				{
+					continue;
+				}
+				if (dependency.GetItem1().Rule() < 0 || dependency.GetItem1().Rule() >= ruleVersions
+					.Length)
+				{
+					incompatible.Append(string.Format("Element %s dependent on unknown rule %d@%d in %s\n"
+						, dependency.GetItem2().ToString(), dependency.GetItem1().Rule(), dependency.GetItem1
+						().Version(), dependency.GetItem1().Recognizer().Name));
+				}
+				else
+				{
+					if (ruleVersions[dependency.GetItem1().Rule()] != dependency.GetItem1().Version())
+					{
+						incompatible.Append(string.Format("Element %s dependent on rule %s@%d (found @%d) in %s\n"
+							, dependency.GetItem2().ToString(), ruleNames[dependency.GetItem1().Rule()], dependency
+							.GetItem1().Version(), ruleVersions[dependency.GetItem1().Rule()], dependency.GetItem1
+							().Recognizer().Name));
+					}
+				}
+			}
+			if (incompatible.Length != 0)
+			{
+				throw new InvalidOperationException(incompatible.ToString());
+			}
+			MarkChecked(recognizerClass);
+		}
+
+		private static int[] GetRuleVersions<_T0>(Type<_T0> recognizerClass, string[] ruleNames
+			) where _T0:Recognizer<object, object>
+		{
+			int[] versions = new int[ruleNames.Length];
+			FieldInfo[] fields = recognizerClass.GetFields();
+			foreach (FieldInfo field in fields)
+			{
+				bool isStatic = (field.GetModifiers() & Modifier.Static) != 0;
+				bool isInteger = field.FieldType == typeof(int);
+				if (isStatic && isInteger && field.Name.StartsWith("RULE_"))
+				{
+					try
+					{
+						string name = Sharpen.Runtime.Substring(field.Name, "RULE_".Length);
+						if (name.IsEmpty() || !System.Char.IsLower(name[0]))
+						{
+							continue;
+						}
+						int index = field.GetInt(null);
+						if (index < 0 || index >= versions.Length)
+						{
+							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);
+							continue;
+						}
+						MethodInfo ruleMethod = GetRuleMethod(recognizerClass, name);
+						if (ruleMethod == null)
+						{
+							object[] @params = new object[] { name, recognizerClass.Name };
+							Logger.Log(Level.Warning, "Could not find rule method for rule ''{0}'' in recognizer {1}."
+								, @params);
+							continue;
+						}
+						RuleVersion ruleVersion = ruleMethod.GetAnnotation<RuleVersion>();
+						int version = ruleVersion != null ? ruleVersion.Value() : 0;
+						versions[index] = version;
+					}
+					catch (ArgumentException ex)
+					{
+						Logger.Log(Level.Warning, null, ex);
+					}
+					catch (MemberAccessException ex)
+					{
+						Logger.Log(Level.Warning, null, ex);
+					}
+				}
+			}
+			return versions;
+		}
+
+		private static MethodInfo GetRuleMethod<_T0>(Type<_T0> recognizerClass, string name
+			) where _T0:Recognizer<object, object>
+		{
+			MethodInfo[] declaredMethods = recognizerClass.GetMethods();
+			foreach (MethodInfo method in declaredMethods)
+			{
+				if (method.Name.Equals(name) && method.IsAnnotationPresent(typeof(RuleVersion)))
+				{
+					return method;
+				}
+			}
+			return null;
+		}
+
+		private static string[] GetRuleNames<_T0>(Type<_T0> recognizerClass) where _T0:Recognizer
+			<object, object>
+		{
+			try
+			{
+				FieldInfo ruleNames = recognizerClass.GetField("ruleNames");
+				return (string[])ruleNames.GetValue(null);
+			}
+			catch (NoSuchFieldException ex)
+			{
+				Logger.Log(Level.Warning, null, ex);
+			}
+			catch (SecurityException ex)
+			{
+				Logger.Log(Level.Warning, null, ex);
+			}
+			catch (ArgumentException ex)
+			{
+				Logger.Log(Level.Warning, null, ex);
+			}
+			catch (MemberAccessException ex)
+			{
+				Logger.Log(Level.Warning, null, ex);
+			}
+			return new string[0];
+		}
+
+		public static IList<Tuple<RuleDependency, AnnotatedElement>> GetDependencies<_T0>
+			(Type<_T0> clazz)
+		{
+			IList<Tuple<RuleDependency, AnnotatedElement>> result = new AList<Tuple<RuleDependency
+				, AnnotatedElement>>();
+			IList<ElementType> supportedTarget = Arrays.AsList(typeof(RuleDependency).GetAnnotation
+				<Target>().Value());
+			foreach (ElementType target in supportedTarget)
+			{
+				switch (target)
+				{
+					case ElementType.Type:
+					{
+						if (!clazz.IsAnnotation())
+						{
+							GetElementDependencies(clazz, result);
+						}
+						break;
+					}
+
+					case ElementType.AnnotationType:
+					{
+						if (!clazz.IsAnnotation())
+						{
+							GetElementDependencies(clazz, result);
+						}
+						break;
+					}
+
+					case ElementType.Constructor:
+					{
+						foreach (Constructor<object> ctor in clazz.GetDeclaredConstructors())
+						{
+							GetElementDependencies(ctor, result);
+						}
+						break;
+					}
+
+					case ElementType.Field:
+					{
+						foreach (FieldInfo field in Sharpen.Runtime.GetDeclaredFields(clazz))
+						{
+							GetElementDependencies(field, result);
+						}
+						break;
+					}
+
+					case ElementType.LocalVariable:
+					{
+						System.Console.Error.WriteLine("Runtime rule dependency checking is not supported for local variables."
+							);
+						break;
+					}
+
+					case ElementType.Method:
+					{
+						foreach (MethodInfo method in Sharpen.Runtime.GetDeclaredMethods(clazz))
+						{
+							GetElementDependencies(method, result);
+						}
+						break;
+					}
+
+					case ElementType.Package:
+					{
+						// package is not a subset of class, so nothing to do here
+						break;
+					}
+
+					case ElementType.Parameter:
+					{
+						System.Console.Error.WriteLine("Runtime rule dependency checking is not supported for parameters."
+							);
+						break;
+					}
+				}
+			}
+			return result;
+		}
+
+		private static void GetElementDependencies(AnnotatedElement annotatedElement, IList
+			<Tuple<RuleDependency, AnnotatedElement>> result)
+		{
+			RuleDependency dependency = annotatedElement.GetAnnotation<RuleDependency>();
+			if (dependency != null)
+			{
+				result.AddItem(Tuple.Create(dependency, annotatedElement));
+			}
+			RuleDependencies dependencies = annotatedElement.GetAnnotation<RuleDependencies>(
+				);
+			if (dependencies != null)
+			{
+				foreach (RuleDependency d in dependencies.Value())
+				{
+					if (d != null)
+					{
+						result.AddItem(Tuple.Create(d, annotatedElement));
+					}
+				}
+			}
+		}
+
+		public RuleDependencyChecker()
+		{
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
new file mode 100644
index 000000000..e75bf6e46
--- /dev/null
+++ b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
@@ -0,0 +1,865 @@
+/*
+ * [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;
+using System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using Javax.Annotation.Processing;
+using Javax.Lang.Model.Element;
+using Javax.Lang.Model.Type;
+using Javax.Tools;
+using Sharpen;
+using Sharpen.Annotation;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>A compile-time validator for rule dependencies.</summary>
+	/// <remarks>A compile-time validator for rule dependencies.</remarks>
+	/// <seealso cref="Antlr4.Runtime.RuleDependency">Antlr4.Runtime.RuleDependency</seealso>
+	/// <seealso cref="Antlr4.Runtime.RuleDependencies">Antlr4.Runtime.RuleDependencies</seealso>
+	/// <author>Sam Harwell</author>
+	public class RuleDependencyProcessor : AbstractProcessor
+	{
+		public static readonly string RuleDependencyClassName = "org.antlr.v4.runtime.RuleDependency";
+
+		public static readonly string RuleDependenciesClassName = "org.antlr.v4.runtime.RuleDependencies";
+
+		public static readonly string RuleVersionClassName = "org.antlr.v4.runtime.RuleVersion";
+
+		public RuleDependencyProcessor()
+		{
+		}
+
+		public override bool Process<_T0>(ICollection<_T0> annotations, RoundEnvironment 
+			roundEnv)
+		{
+			if (!CheckClassNameConstants())
+			{
+				return true;
+			}
+			IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> dependencies = GetDependencies
+				(roundEnv);
+			IDictionary<TypeMirror, IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element
+				>>> recognizerDependencies = new Dictionary<TypeMirror, IList<Tuple<RuleDependency
+				, Javax.Lang.Model.Element.Element>>>();
+			foreach (Tuple<RuleDependency, Javax.Lang.Model.Element.Element> dependency in dependencies)
+			{
+				TypeMirror recognizerType = GetRecognizerType(dependency.GetItem1());
+				IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> list = recognizerDependencies
+					.Get(recognizerType);
+				if (list == null)
+				{
+					list = new AList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>>();
+					recognizerDependencies.Put(recognizerType, list);
+				}
+				list.AddItem(dependency);
+			}
+			foreach (KeyValuePair<TypeMirror, IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element
+				>>> entry in recognizerDependencies.EntrySet())
+			{
+				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Note, string.Format("ANTLR 4: Validating %d dependencies on rules in %s."
+					, entry.Value.Count, entry.Key.ToString()));
+				CheckDependencies(entry.Value, entry.Key);
+			}
+			return true;
+		}
+
+		private bool CheckClassNameConstants()
+		{
+			bool success = CheckClassNameConstant(RuleDependencyClassName, typeof(RuleDependency
+				));
+			success &= CheckClassNameConstant(RuleDependenciesClassName, typeof(RuleDependencies
+				));
+			success &= CheckClassNameConstant(RuleVersionClassName, typeof(RuleVersion));
+			return success;
+		}
+
+		private bool CheckClassNameConstant<_T0>(string className, System.Type<_T0> clazz
+			)
+		{
+			Args.NotNull("className", className);
+			Args.NotNull("clazz", clazz);
+			if (!className.Equals(clazz.GetCanonicalName()))
+			{
+				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, string.Format("Unable to process rule dependencies due to class name mismatch: %s != %s"
+					, className, clazz.GetCanonicalName()));
+				return false;
+			}
+			return true;
+		}
+
+		private static TypeMirror GetRecognizerType(RuleDependency dependency)
+		{
+			try
+			{
+				dependency.Recognizer();
+				string message = string.Format("Expected %s to get the %s.", typeof(MirroredTypeException
+					).Name, typeof(TypeMirror).Name);
+				throw new NotSupportedException(message);
+			}
+			catch (MirroredTypeException ex)
+			{
+				return ex.GetTypeMirror();
+			}
+		}
+
+		private void CheckDependencies(IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element
+			>> dependencies, TypeMirror recognizerType)
+		{
+			string[] ruleNames = GetRuleNames(recognizerType);
+			int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
+			RuleDependencyProcessor.RuleRelations relations = ExtractRuleRelations(recognizerType
+				);
+			foreach (Tuple<RuleDependency, Javax.Lang.Model.Element.Element> dependency in dependencies)
+			{
+				try
+				{
+					if (!processingEnv.GetTypeUtils().IsAssignable(GetRecognizerType(dependency.GetItem1
+						()), recognizerType))
+					{
+						continue;
+					}
+					// this is the rule in the dependency set with the highest version number
+					int effectiveRule = dependency.GetItem1().Rule();
+					if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
+					{
+						Tuple<AnnotationMirror, AnnotationValue> ruleReferenceElement = FindRuleDependencyProperty
+							(dependency, RuleDependencyProcessor.RuleDependencyProperty.Rule);
+						string message = string.Format("Rule dependency on unknown rule %d@%d in %s", dependency
+							.GetItem1().Rule(), dependency.GetItem1().Version(), GetRecognizerType(dependency
+							.GetItem1()).ToString());
+						if (ruleReferenceElement != null)
+						{
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+								.GetItem2(), ruleReferenceElement.GetItem1(), ruleReferenceElement.GetItem2());
+						}
+						else
+						{
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+								.GetItem2());
+						}
+						continue;
+					}
+					EnumSet<Dependents> dependents = EnumSet.Of(Dependents.Self, dependency.GetItem1(
+						).Dependents());
+					ReportUnimplementedDependents(dependency, dependents);
+					BitSet checked = new BitSet();
+					int highestRequiredDependency = CheckDependencyVersion(dependency, ruleNames, ruleVersions
+						, effectiveRule, null);
+					if (dependents.Contains(Dependents.Parents))
+					{
+						BitSet parents = relations.parents[dependency.GetItem1().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(dependency, ruleNames, ruleVersions, parent
+								, "parent");
+							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+						}
+					}
+					if (dependents.Contains(Dependents.Children))
+					{
+						BitSet children = relations.children[dependency.GetItem1().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(dependency, ruleNames, ruleVersions, child, 
+								"child");
+							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+						}
+					}
+					if (dependents.Contains(Dependents.Ancestors))
+					{
+						BitSet ancestors = relations.GetAncestors(dependency.GetItem1().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(dependency, ruleNames, ruleVersions, ancestor
+								, "ancestor");
+							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+						}
+					}
+					if (dependents.Contains(Dependents.Descendants))
+					{
+						BitSet descendants = relations.GetDescendants(dependency.GetItem1().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(dependency, ruleNames, ruleVersions, descendant
+								, "descendant");
+							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+						}
+					}
+					int declaredVersion = dependency.GetItem1().Version();
+					if (declaredVersion > highestRequiredDependency)
+					{
+						Tuple<AnnotationMirror, AnnotationValue> versionElement = FindRuleDependencyProperty
+							(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
+						string message = string.Format("Rule dependency version mismatch: %s has maximum dependency version %d (expected %d) in %s"
+							, ruleNames[dependency.GetItem1().Rule()], highestRequiredDependency, declaredVersion
+							, GetRecognizerType(dependency.GetItem1()).ToString());
+						if (versionElement != null)
+						{
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+								.GetItem2(), versionElement.GetItem1(), versionElement.GetItem2());
+						}
+						else
+						{
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+								.GetItem2());
+						}
+					}
+				}
+				catch (AnnotationTypeMismatchException)
+				{
+					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, string.Format("Could not validate rule dependencies for element %s"
+						, dependency.GetItem2().ToString()), dependency.GetItem2());
+				}
+			}
+		}
+
+		private static readonly ICollection<Dependents> ImplementedDependents = EnumSet.Of
+			(Dependents.Self, Dependents.Parents, Dependents.Children, Dependents.Ancestors, 
+			Dependents.Descendants);
+
+		private void ReportUnimplementedDependents(Tuple<RuleDependency, Javax.Lang.Model.Element.Element
+			> dependency, EnumSet<Dependents> dependents)
+		{
+			EnumSet<Dependents> unimplemented = dependents.Clone();
+			unimplemented.RemoveAll(ImplementedDependents);
+			if (!unimplemented.IsEmpty())
+			{
+				Tuple<AnnotationMirror, AnnotationValue> dependentsElement = FindRuleDependencyProperty
+					(dependency, RuleDependencyProcessor.RuleDependencyProperty.Dependents);
+				if (dependentsElement == null)
+				{
+					dependentsElement = FindRuleDependencyProperty(dependency, RuleDependencyProcessor.RuleDependencyProperty
+						.Rule);
+				}
+				string message = string.Format("Cannot validate the following dependents of rule %d: %s"
+					, dependency.GetItem1().Rule(), unimplemented);
+				if (dependentsElement != null)
+				{
+					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, message, dependency
+						.GetItem2(), dependentsElement.GetItem1(), dependentsElement.GetItem2());
+				}
+				else
+				{
+					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, message, dependency
+						.GetItem2());
+				}
+			}
+		}
+
+		private int CheckDependencyVersion(Tuple<RuleDependency, Javax.Lang.Model.Element.Element
+			> dependency, string[] ruleNames, int[] ruleVersions, int relatedRule, string relation
+			)
+		{
+			string ruleName = ruleNames[dependency.GetItem1().Rule()];
+			string path;
+			if (relation == null)
+			{
+				path = ruleName;
+			}
+			else
+			{
+				string mismatchedRuleName = ruleNames[relatedRule];
+				path = string.Format("rule %s (%s of %s)", mismatchedRuleName, relation, ruleName
+					);
+			}
+			int declaredVersion = dependency.GetItem1().Version();
+			int actualVersion = ruleVersions[relatedRule];
+			if (actualVersion > declaredVersion)
+			{
+				Tuple<AnnotationMirror, AnnotationValue> versionElement = FindRuleDependencyProperty
+					(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
+				string message = string.Format("Rule dependency version mismatch: %s has version %d (expected <= %d) in %s"
+					, path, actualVersion, declaredVersion, GetRecognizerType(dependency.GetItem1())
+					.ToString());
+				if (versionElement != null)
+				{
+					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+						.GetItem2(), versionElement.GetItem1(), versionElement.GetItem2());
+				}
+				else
+				{
+					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+						.GetItem2());
+				}
+			}
+			return actualVersion;
+		}
+
+		private int[] GetRuleVersions(TypeMirror recognizerClass, string[] ruleNames)
+		{
+			int[] versions = new int[ruleNames.Length];
+			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
+				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
+				));
+			foreach (Javax.Lang.Model.Element.Element element in elements)
+			{
+				if (element.GetKind() != ElementKind.Field)
+				{
+					continue;
+				}
+				VariableElement field = (VariableElement)element;
+				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
+				object constantValue = field.GetConstantValue();
+				bool isInteger = constantValue is int;
+				string name = field.GetSimpleName().ToString();
+				if (isStatic && isInteger && name.StartsWith("RULE_"))
+				{
+					try
+					{
+						name = Sharpen.Runtime.Substring(name, "RULE_".Length);
+						if (name.IsEmpty() || !System.Char.IsLower(name[0]))
+						{
+							continue;
+						}
+						int index = (int)constantValue;
+						if (index < 0 || index >= versions.Length)
+						{
+							string message = string.Format("Rule index %d for rule '%s' out of bounds for recognizer %s."
+								, index, name, recognizerClass.ToString());
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
+							continue;
+						}
+						if (name.IndexOf(ATNSimulator.RuleVariantDelimiter) >= 0)
+						{
+							// ignore left-factored pseudo-rules
+							continue;
+						}
+						ExecutableElement ruleMethod = GetRuleMethod(recognizerClass, name);
+						if (ruleMethod == null)
+						{
+							string message = string.Format("Could not find rule method for rule '%s' in recognizer %s."
+								, name, recognizerClass.ToString());
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
+							continue;
+						}
+						RuleVersion ruleVersion = ruleMethod.GetAnnotation<RuleVersion>();
+						int version = ruleVersion != null ? ruleVersion.Value() : 0;
+						versions[index] = version;
+					}
+					catch (ArgumentException)
+					{
+						processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
+							, element);
+					}
+				}
+			}
+			return versions;
+		}
+
+		private ExecutableElement GetRuleMethod(TypeMirror recognizerClass, string name)
+		{
+			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
+				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
+				));
+			foreach (Javax.Lang.Model.Element.Element element in elements)
+			{
+				if (element.GetKind() != ElementKind.Method)
+				{
+					continue;
+				}
+				ExecutableElement method = (ExecutableElement)element;
+				if (method.GetSimpleName().ContentEquals(name) && HasRuleVersionAnnotation(method
+					))
+				{
+					return method;
+				}
+			}
+			return null;
+		}
+
+		private bool HasRuleVersionAnnotation(ExecutableElement method)
+		{
+			TypeElement ruleVersionAnnotationElement = processingEnv.GetElementUtils().GetTypeElement
+				(RuleVersionClassName);
+			if (ruleVersionAnnotationElement == null)
+			{
+				return false;
+			}
+			foreach (AnnotationMirror annotation in method.GetAnnotationMirrors())
+			{
+				if (processingEnv.GetTypeUtils().IsSameType(annotation.GetAnnotationType(), ruleVersionAnnotationElement
+					.AsType()))
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		private string[] GetRuleNames(TypeMirror recognizerClass)
+		{
+			IList<string> result = new AList<string>();
+			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
+				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
+				));
+			foreach (Javax.Lang.Model.Element.Element element in elements)
+			{
+				if (element.GetKind() != ElementKind.Field)
+				{
+					continue;
+				}
+				VariableElement field = (VariableElement)element;
+				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
+				object constantValue = field.GetConstantValue();
+				bool isInteger = constantValue is int;
+				string name = field.GetSimpleName().ToString();
+				if (isStatic && isInteger && name.StartsWith("RULE_"))
+				{
+					try
+					{
+						name = Sharpen.Runtime.Substring(name, "RULE_".Length);
+						if (name.IsEmpty() || !System.Char.IsLower(name[0]))
+						{
+							continue;
+						}
+						int index = (int)constantValue;
+						if (index < 0)
+						{
+							continue;
+						}
+						while (result.Count <= index)
+						{
+							result.AddItem(string.Empty);
+						}
+						result.Set(index, name);
+					}
+					catch (ArgumentException)
+					{
+						processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
+							, element);
+					}
+				}
+			}
+			return Sharpen.Collections.ToArray(result, new string[result.Count]);
+		}
+
+		public static IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> GetDependencies
+			(RoundEnvironment roundEnv)
+		{
+			IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> result = new AList
+				<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>>();
+			ICollection<Javax.Lang.Model.Element.Element> elements = roundEnv.GetElementsAnnotatedWith
+				(typeof(RuleDependency));
+			foreach (Javax.Lang.Model.Element.Element element in elements)
+			{
+				RuleDependency dependency = element.GetAnnotation<RuleDependency>();
+				if (dependency == null)
+				{
+					continue;
+				}
+				result.AddItem(Tuple.Create(dependency, element));
+			}
+			elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependencies));
+			foreach (Javax.Lang.Model.Element.Element element_1 in elements)
+			{
+				RuleDependencies dependencies = element_1.GetAnnotation<RuleDependencies>();
+				if (dependencies == null || dependencies.Value() == null)
+				{
+					continue;
+				}
+				foreach (RuleDependency dependency in dependencies.Value())
+				{
+					result.AddItem(Tuple.Create(dependency, element_1));
+				}
+			}
+			return result;
+		}
+
+		public enum RuleDependencyProperty
+		{
+			Recognizer,
+			Rule,
+			Version,
+			Dependents
+		}
+
+		[Nullable]
+		private Tuple<AnnotationMirror, AnnotationValue> FindRuleDependencyProperty(Tuple
+			<RuleDependency, Javax.Lang.Model.Element.Element> dependency, RuleDependencyProcessor.RuleDependencyProperty
+			 property)
+		{
+			TypeElement ruleDependencyTypeElement = processingEnv.GetElementUtils().GetTypeElement
+				(RuleDependencyClassName);
+			TypeElement ruleDependenciesTypeElement = processingEnv.GetElementUtils().GetTypeElement
+				(RuleDependenciesClassName);
+			IList<AnnotationMirror> mirrors = dependency.GetItem2().GetAnnotationMirrors();
+			foreach (AnnotationMirror annotationMirror in mirrors)
+			{
+				if (processingEnv.GetTypeUtils().IsSameType(ruleDependencyTypeElement.AsType(), annotationMirror
+					.GetAnnotationType()))
+				{
+					AnnotationValue element = FindRuleDependencyProperty(dependency, annotationMirror
+						, property);
+					if (element != null)
+					{
+						return Tuple.Create(annotationMirror, element);
+					}
+				}
+				else
+				{
+					if (processingEnv.GetTypeUtils().IsSameType(ruleDependenciesTypeElement.AsType(), 
+						annotationMirror.GetAnnotationType()))
+					{
+						IDictionary<ExecutableElement, AnnotationValue> values = annotationMirror.GetElementValues
+							();
+						foreach (KeyValuePair<ExecutableElement, AnnotationValue> value in values.EntrySet
+							())
+						{
+							if ("value()".Equals(value.Key.ToString()))
+							{
+								AnnotationValue annotationValue = value.Value;
+								if (!(annotationValue.GetValue() is IList))
+								{
+									processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected array of RuleDependency annotations for annotation property 'value()'."
+										, dependency.GetItem2(), annotationMirror, annotationValue);
+									break;
+								}
+								IList<object> annotationValueList = (IList<object>)annotationValue.GetValue();
+								foreach (object obj in annotationValueList)
+								{
+									if (!(obj is AnnotationMirror))
+									{
+										processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected RuleDependency annotation mirror for element of property 'value()'."
+											, dependency.GetItem2(), annotationMirror, annotationValue);
+										break;
+									}
+									AnnotationValue element = FindRuleDependencyProperty(dependency, (AnnotationMirror
+										)obj, property);
+									if (element != null)
+									{
+										return Tuple.Create((AnnotationMirror)obj, element);
+									}
+								}
+							}
+							else
+							{
+								processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, string.Format("Unexpected annotation property %s."
+									, value.Key.ToString()), dependency.GetItem2(), annotationMirror, value.Value);
+							}
+						}
+					}
+				}
+			}
+			return null;
+		}
+
+		[Nullable]
+		private AnnotationValue FindRuleDependencyProperty(Tuple<RuleDependency, Javax.Lang.Model.Element.Element
+			> dependency, AnnotationMirror annotationMirror, RuleDependencyProcessor.RuleDependencyProperty
+			 property)
+		{
+			AnnotationValue recognizerValue = null;
+			AnnotationValue ruleValue = null;
+			AnnotationValue versionValue = null;
+			AnnotationValue dependentsValue = null;
+			IDictionary<ExecutableElement, AnnotationValue> values = annotationMirror.GetElementValues
+				();
+			foreach (KeyValuePair<ExecutableElement, AnnotationValue> value in values.EntrySet
+				())
+			{
+				AnnotationValue annotationValue = value.Value;
+				if ("rule()".Equals(value.Key.ToString()))
+				{
+					ruleValue = annotationValue;
+					if (!(annotationValue.GetValue() is int))
+					{
+						processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'rule()'."
+							, dependency.GetItem2(), annotationMirror, annotationValue);
+						return null;
+					}
+					if ((int)annotationValue.GetValue() != dependency.GetItem1().Rule())
+					{
+						// this is a valid dependency annotation, but not the one we're looking for
+						return null;
+					}
+				}
+				else
+				{
+					if ("recognizer()".Equals(value.Key.ToString()))
+					{
+						recognizerValue = annotationValue;
+						if (!(annotationValue.GetValue() is TypeMirror))
+						{
+							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected Class constant for annotation property 'recognizer()'."
+								, dependency.GetItem2(), annotationMirror, annotationValue);
+							return null;
+						}
+						TypeMirror annotationRecognizer = (TypeMirror)annotationValue.GetValue();
+						TypeMirror expectedRecognizer = GetRecognizerType(dependency.GetItem1());
+						if (!processingEnv.GetTypeUtils().IsSameType(expectedRecognizer, annotationRecognizer
+							))
+						{
+							// this is a valid dependency annotation, but not the one we're looking for
+							return null;
+						}
+					}
+					else
+					{
+						if ("version()".Equals(value.Key.ToString()))
+						{
+							versionValue = annotationValue;
+							if (!(annotationValue.GetValue() is int))
+							{
+								processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'version()'."
+									, dependency.GetItem2(), annotationMirror, annotationValue);
+								return null;
+							}
+							if ((int)annotationValue.GetValue() != dependency.GetItem1().Version())
+							{
+								// this is a valid dependency annotation, but not the one we're looking for
+								return null;
+							}
+						}
+					}
+				}
+			}
+			if (recognizerValue != null)
+			{
+				if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
+				{
+					return recognizerValue;
+				}
+				else
+				{
+					if (ruleValue != null)
+					{
+						if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
+						{
+							return ruleValue;
+						}
+						else
+						{
+							if (versionValue != null)
+							{
+								if (property == RuleDependencyProcessor.RuleDependencyProperty.Version)
+								{
+									return versionValue;
+								}
+								else
+								{
+									if (property == RuleDependencyProcessor.RuleDependencyProperty.Dependents)
+									{
+										return dependentsValue;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			if (recognizerValue == null)
+			{
+				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'recognizer()' element in annotation."
+					, dependency.GetItem2(), annotationMirror);
+			}
+			if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
+			{
+				return null;
+			}
+			if (ruleValue == null)
+			{
+				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'rule()' element in annotation."
+					, dependency.GetItem2(), annotationMirror);
+			}
+			if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
+			{
+				return null;
+			}
+			if (versionValue == null)
+			{
+				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'version()' element in annotation."
+					, dependency.GetItem2(), annotationMirror);
+			}
+			return null;
+		}
+
+		private RuleDependencyProcessor.RuleRelations ExtractRuleRelations(TypeMirror recognizer
+			)
+		{
+			string serializedATN = GetSerializedATN(recognizer);
+			if (serializedATN == null)
+			{
+				return null;
+			}
+			ATN atn = ATNSimulator.Deserialize(serializedATN.ToCharArray());
+			RuleDependencyProcessor.RuleRelations relations = new RuleDependencyProcessor.RuleRelations
+				(atn.ruleToStartState.Length);
+			foreach (ATNState state in atn.states)
+			{
+				if (!state.epsilonOnlyTransitions)
+				{
+					continue;
+				}
+				foreach (Transition transition in state.GetTransitions())
+				{
+					if (transition.GetSerializationType() != Transition.Rule)
+					{
+						continue;
+					}
+					RuleTransition ruleTransition = (RuleTransition)transition;
+					relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
+				}
+			}
+			return relations;
+		}
+
+		private string GetSerializedATN(TypeMirror recognizerClass)
+		{
+			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
+				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
+				));
+			foreach (Javax.Lang.Model.Element.Element element in elements)
+			{
+				if (element.GetKind() != ElementKind.Field)
+				{
+					continue;
+				}
+				VariableElement field = (VariableElement)element;
+				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
+				object constantValue = field.GetConstantValue();
+				bool isString = constantValue is string;
+				string name = field.GetSimpleName().ToString();
+				if (isStatic && isString && name.Equals("_serializedATN"))
+				{
+					return (string)constantValue;
+				}
+			}
+			processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Could not retrieve serialized ATN from grammar."
+				);
+			return null;
+		}
+
+		private sealed class RuleRelations
+		{
+			private readonly BitSet[] parents;
+
+			private 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;
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/TestRig.cs b/Antlr4.Runtime/Misc/TestRig.cs
new file mode 100644
index 000000000..9d8dbaf4a
--- /dev/null
+++ b/Antlr4.Runtime/Misc/TestRig.cs
@@ -0,0 +1,337 @@
+/*
+ * [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.Reflection;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Sharpen;
+using Sharpen.Reflect;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <summary>
+	/// Run a lexer/parser combo, optionally printing tree string or generating
+	/// postscript file.
+	/// </summary>
+	/// <remarks>
+	/// 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)]
+	/// </remarks>
+	public class TestRig
+	{
+		public static readonly string LexerStartRuleName = "tokens";
+
+		protected internal string grammarName;
+
+		protected internal string startRuleName;
+
+		protected internal readonly IList<string> inputFiles = new AList<string>();
+
+		protected internal bool printTree = false;
+
+		protected internal bool gui = false;
+
+		protected internal string psFile = null;
+
+		protected internal bool showTokens = false;
+
+		protected internal bool trace = false;
+
+		protected internal bool diagnostics = false;
+
+		protected internal string encoding = null;
+
+		protected internal bool Sll = false;
+
+		/// <exception cref="System.Exception"></exception>
+		public TestRig(string[] args)
+		{
+			if (args.Length < 2)
+			{
+				System.Console.Error.WriteLine("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.Console.Error.WriteLine("Use startRuleName='tokens' if GrammarName is a lexer grammar."
+					);
+				System.Console.Error.WriteLine("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[0] != '-')
+				{
+					// input file name
+					inputFiles.AddItem(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.Console.Error.WriteLine("missing encoding on -encoding");
+										return;
+									}
+									encoding = args[i];
+									i++;
+								}
+								else
+								{
+									if (arg.Equals("-ps"))
+									{
+										if (i >= args.Length)
+										{
+											System.Console.Error.WriteLine("missing filename on -ps");
+											return;
+										}
+										psFile = args[i];
+										i++;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		/// <exception cref="System.Exception"></exception>
+		public static void Main(string[] args)
+		{
+			Antlr4.Runtime.Misc.TestRig testRig = new Antlr4.Runtime.Misc.TestRig(args);
+			testRig.Process();
+		}
+
+		/// <exception cref="System.Exception"></exception>
+		public virtual void Process()
+		{
+			//		System.out.println("exec "+grammarName+"."+startRuleName);
+			string lexerName = grammarName + "Lexer";
+			ClassLoader cl = Sharpen.Thread.CurrentThread().GetContextClassLoader();
+			Type lexerClass = null;
+			try
+			{
+				lexerClass = cl.LoadClass(lexerName).AsSubclass<Lexer>();
+			}
+			catch (TypeLoadException)
+			{
+				// might be pure lexer grammar; no Lexer suffix then
+				lexerName = grammarName;
+				try
+				{
+					lexerClass = cl.LoadClass(lexerName).AsSubclass<Lexer>();
+				}
+				catch (TypeLoadException)
+				{
+					System.Console.Error.WriteLine("Can't load " + lexerName + " as lexer or parser");
+					return;
+				}
+			}
+			Constructor<Lexer> lexerCtor = lexerClass.GetConstructor(typeof(CharStream));
+			Lexer lexer = lexerCtor.NewInstance((CharStream)null);
+			Type parserClass = null;
+			Parser parser = null;
+			if (!startRuleName.Equals(LexerStartRuleName))
+			{
+				string parserName = grammarName + "Parser";
+				parserClass = (Type)cl.LoadClass(parserName).AsSubclass<Parser>();
+				if (parserClass == null)
+				{
+					System.Console.Error.WriteLine("Can't load " + parserName);
+				}
+				Constructor<Parser> parserCtor = parserClass.GetConstructor(typeof(TokenStream));
+				parser = parserCtor.NewInstance((TokenStream)null);
+			}
+			if (inputFiles.IsEmpty())
+			{
+				InputStream @is = Sharpen.Runtime.@in;
+				StreamReader r;
+				if (encoding != null)
+				{
+					r = new InputStreamReader(@is, encoding);
+				}
+				else
+				{
+					r = new InputStreamReader(@is);
+				}
+				Process(lexer, parserClass, parser, @is, r);
+				return;
+			}
+			foreach (string inputFile in inputFiles)
+			{
+				InputStream @is = Sharpen.Runtime.@in;
+				if (inputFile != null)
+				{
+					@is = new FileInputStream(inputFile);
+				}
+				StreamReader r;
+				if (encoding != null)
+				{
+					r = new InputStreamReader(@is, encoding);
+				}
+				else
+				{
+					r = new InputStreamReader(@is);
+				}
+				if (inputFiles.Count > 1)
+				{
+					System.Console.Error.WriteLine(inputFile);
+				}
+				Process(lexer, parserClass, parser, @is, r);
+			}
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		/// <exception cref="System.MemberAccessException"></exception>
+		/// <exception cref="System.Reflection.TargetInvocationException"></exception>
+		/// <exception cref="Javax.Print.PrintException"></exception>
+		protected internal virtual void Process<_T0>(Lexer lexer, Type<_T0> parserClass, 
+			Parser parser, InputStream @is, StreamReader r) where _T0:Parser
+		{
+			try
+			{
+				ANTLRInputStream input = new ANTLRInputStream(r);
+				lexer.SetInputStream(input);
+				CommonTokenStream tokens = new CommonTokenStream(lexer);
+				tokens.Fill();
+				if (showTokens)
+				{
+					foreach (object tok in tokens.GetTokens())
+					{
+						System.Console.Out.WriteLine(tok);
+					}
+				}
+				if (startRuleName.Equals(LexerStartRuleName))
+				{
+					return;
+				}
+				if (diagnostics)
+				{
+					parser.AddErrorListener(new DiagnosticErrorListener());
+					parser.GetInterpreter().SetPredictionMode(PredictionMode.LlExactAmbigDetection);
+				}
+				if (printTree || gui || psFile != null)
+				{
+					parser.SetBuildParseTree(true);
+				}
+				if (Sll)
+				{
+					// overrides diagnostics
+					parser.GetInterpreter().SetPredictionMode(PredictionMode.Sll);
+				}
+				parser.SetInputStream(tokens);
+				parser.SetTrace(trace);
+				try
+				{
+					MethodInfo startRule = parserClass.GetMethod(startRuleName, (Type[])null);
+					ParserRuleContext tree = (ParserRuleContext)startRule.Invoke(parser, (object[])null
+						);
+					if (printTree)
+					{
+						System.Console.Out.WriteLine(tree.ToStringTree(parser));
+					}
+					if (gui)
+					{
+						tree.Inspect(parser);
+					}
+					if (psFile != null)
+					{
+						tree.Save(parser, psFile);
+					}
+				}
+				catch (NoSuchMethodException)
+				{
+					// Generate postscript
+					System.Console.Error.WriteLine("No method for rule " + startRuleName + " or it has arguments"
+						);
+				}
+			}
+			finally
+			{
+				if (r != null)
+				{
+					r.Close();
+				}
+				if (@is != null)
+				{
+					@is.Close();
+				}
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Tuple.cs b/Antlr4.Runtime/Misc/Tuple.cs
new file mode 100644
index 000000000..41186b700
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Tuple.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;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public class Tuple<T1, T2, T3>
+	{
+		private readonly T1 item1;
+
+		private readonly T2 item2;
+
+		private readonly T3 item3;
+
+		public Tuple(T1 item1, T2 item2, T3 item3)
+		{
+			this.item1 = item1;
+			this.item2 = item2;
+			this.item3 = item3;
+		}
+
+		public T1 GetItem1()
+		{
+			return item1;
+		}
+
+		public T2 GetItem2()
+		{
+			return item2;
+		}
+
+		public T3 GetItem3()
+		{
+			return item3;
+		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == this)
+			{
+				return true;
+			}
+			else
+			{
+				if (!(obj is Tuple<object, object, object>))
+				{
+					return false;
+				}
+			}
+			Tuple<object, object, object> other = (Tuple<object, object, object>)obj;
+			return Tuple.Equals(this.item1, other.item1) && Tuple.Equals(this.item2, other.item2
+				) && Tuple.Equals(this.item3, other.item3);
+		}
+
+		public override int GetHashCode()
+		{
+			int hash = 5;
+			hash = 79 * hash + (this.item1 != null ? this.item1.GetHashCode() : 0);
+			hash = 79 * hash + (this.item2 != null ? this.item2.GetHashCode() : 0);
+			hash = 79 * hash + (this.item3 != null ? this.item3.GetHashCode() : 0);
+			return hash;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Utils.cs b/Antlr4.Runtime/Misc/Utils.cs
new file mode 100644
index 000000000..dd210b008
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Utils.cs
@@ -0,0 +1,258 @@
+/*
+ * [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.Text;
+using Antlr4.Runtime.Misc;
+using Java.Awt;
+using Java.Awt.Event;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	public class Utils
+	{
+		public static string Join<_T0>(IEnumerable<_T0> iter, string separator)
+		{
+			return Join(iter.GetEnumerator(), separator);
+		}
+
+		public static string Join<T>(T[] array, string separator)
+		{
+			return Join(Arrays.AsList(array), separator);
+		}
+
+		// Seriously: why isn't this built in to java? ugh!
+		public static string Join<T>(IEnumerator<T> iter, string separator)
+		{
+			StringBuilder buf = new StringBuilder();
+			while (iter.HasNext())
+			{
+				buf.Append(iter.Next());
+				if (iter.HasNext())
+				{
+					buf.Append(separator);
+				}
+			}
+			return buf.ToString();
+		}
+
+		public static bool Equals(object x, object y)
+		{
+			if (x == y)
+			{
+				return true;
+			}
+			if (x == null || y == null)
+			{
+				return false;
+			}
+			return x.Equals(y);
+		}
+
+		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();
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public static void WriteFile(string fileName, string content)
+		{
+			FileWriter fw = new FileWriter(fileName);
+			TextWriter w = new BufferedWriter(fw);
+			w.Write(content);
+			w.Close();
+		}
+
+		public static void RemoveAll<T, _T1>(IList<T> list, Predicate<_T1> predicate)
+		{
+			int j = 0;
+			for (int i = 0; i < list.Count; i++)
+			{
+				T item = list[i];
+				if (!predicate.Eval(item))
+				{
+					if (j != i)
+					{
+						list.Set(j, item);
+					}
+					j++;
+				}
+			}
+			if (j < list.Count)
+			{
+				list.SubList(j, list.Count).Clear();
+			}
+		}
+
+		public static void RemoveAll<T, _T1>(IEnumerable<T> iterable, Predicate<_T1> predicate
+			)
+		{
+			if (iterable is IList<object>)
+			{
+				RemoveAll((IList<T>)iterable, predicate);
+				return;
+			}
+			for (IEnumerator<T> iterator = iterable.GetEnumerator(); iterator.HasNext(); )
+			{
+				T item = iterator.Next();
+				if (predicate.Eval(item))
+				{
+					iterator.Remove();
+				}
+			}
+		}
+
+		/// <exception cref="System.Exception"></exception>
+		public static void WaitForClose(Window window)
+		{
+			object Lock = new object();
+			Sharpen.Thread t = new _Thread_146(Lock, window);
+			t.Start();
+			window.AddWindowListener(new _WindowAdapter_162(Lock, window));
+			t.Join();
+		}
+
+		private sealed class _Thread_146 : Sharpen.Thread
+		{
+			public _Thread_146(object Lock, Window window)
+			{
+				this.Lock = Lock;
+				this.window = window;
+			}
+
+			public override void Run()
+			{
+				lock (Lock)
+				{
+					while (window.IsVisible())
+					{
+						try
+						{
+							Sharpen.Runtime.Wait(Lock, 500);
+						}
+						catch (Exception)
+						{
+						}
+					}
+				}
+			}
+
+			private readonly object Lock;
+
+			private readonly Window window;
+		}
+
+		private sealed class _WindowAdapter_162 : WindowAdapter
+		{
+			public _WindowAdapter_162(object Lock, Window window)
+			{
+				this.Lock = Lock;
+				this.window = window;
+			}
+
+			public override void WindowClosing(WindowEvent arg0)
+			{
+				lock (Lock)
+				{
+					window.SetVisible(false);
+					Sharpen.Runtime.Notify(Lock);
+				}
+			}
+
+			private readonly object Lock;
+
+			private readonly Window window;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/NoViableAltException.cs b/Antlr4.Runtime/NoViableAltException.cs
new file mode 100644
index 000000000..e075d2d4b
--- /dev/null
+++ b/Antlr4.Runtime/NoViableAltException.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;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Misc;
+using 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 Token startToken;
+
+		public NoViableAltException(Parser recognizer) : this(recognizer, ((TokenStream)recognizer
+			.GetInputStream()), recognizer.GetCurrentToken(), recognizer.GetCurrentToken(), 
+			null, recognizer._ctx)
+		{
+		}
+
+		public NoViableAltException(Recognizer<Token, object> recognizer, TokenStream input
+			, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext
+			 ctx) : base(recognizer, input, ctx)
+		{
+			// LL(1) error
+			this.deadEndConfigs = deadEndConfigs;
+			this.startToken = startToken;
+			this.SetOffendingToken(offendingToken);
+		}
+
+		public virtual Token GetStartToken()
+		{
+			return startToken;
+		}
+
+		[Nullable]
+		public virtual ATNConfigSet GetDeadEndConfigs()
+		{
+			return deadEndConfigs;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Parser.cs b/Antlr4.Runtime/Parser.cs
new file mode 100644
index 000000000..5f3356283
--- /dev/null
+++ b/Antlr4.Runtime/Parser.cs
@@ -0,0 +1,922 @@
+/*
+ * [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;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
+using Sharpen;
+
+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<Token, ParserATNSimulator>
+	{
+		public class TraceListener : ParseTreeListener
+		{
+			public virtual void EnterEveryRule(ParserRuleContext ctx)
+			{
+				System.Console.Out.WriteLine("enter   " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
+					()] + ", LT(1)=" + this._enclosing._input.Lt(1).GetText());
+			}
+
+			public virtual void ExitEveryRule(ParserRuleContext ctx)
+			{
+				System.Console.Out.WriteLine("exit    " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
+					()] + ", LT(1)=" + this._enclosing._input.Lt(1).GetText());
+			}
+
+			public virtual void VisitErrorNode(ErrorNode node)
+			{
+			}
+
+			public virtual void VisitTerminal(TerminalNode node)
+			{
+				ParserRuleContext parent = (ParserRuleContext)node.GetParent().GetRuleContext();
+				Token token = node.GetSymbol();
+				System.Console.Out.WriteLine("consume " + token + " rule " + this._enclosing.GetRuleNames
+					()[parent.GetRuleIndex()] + " alt=" + parent.altNum);
+			}
+
+			internal TraceListener(Parser _enclosing)
+			{
+				this._enclosing = _enclosing;
+			}
+
+			private readonly Parser _enclosing;
+		}
+
+		public class TrimToSizeListener : ParseTreeListener
+		{
+			public static readonly Parser.TrimToSizeListener Instance = new Parser.TrimToSizeListener
+				();
+
+			public virtual void VisitTerminal(TerminalNode node)
+			{
+			}
+
+			public virtual void VisitErrorNode(ErrorNode node)
+			{
+			}
+
+			public virtual void EnterEveryRule(ParserRuleContext ctx)
+			{
+			}
+
+			public virtual void ExitEveryRule(ParserRuleContext ctx)
+			{
+				if (ctx.children is ArrayList)
+				{
+					((AList<object>)ctx.children).TrimToSize();
+				}
+			}
+		}
+
+		protected internal ANTLRErrorStrategy _errHandler = new DefaultErrorStrategy();
+
+		protected internal TokenStream _input;
+
+		protected internal readonly IntegerStack _precedenceStack;
+
+		/// <summary>The RuleContext object for the currently executing rule.</summary>
+		/// <remarks>
+		/// The RuleContext object for the currently executing rule. This
+		/// must be non-null during parsing, but is initially null.
+		/// When somebody calls the start rule, this gets set to the
+		/// root context.
+		/// </remarks>
+		protected internal ParserRuleContext _ctx;
+
+		protected internal bool _buildParseTrees = true;
+
+		protected internal Parser.TraceListener _tracer;
+
+		/// <summary>
+		/// If the listener is non-null, trigger enter and exit rule events
+		/// *during* the parse.
+		/// </summary>
+		/// <remarks>
+		/// If the listener is non-null, trigger enter and exit rule events
+		/// *during* the parse. This is typically done only when not building
+		/// parse trees for later visiting. We either trigger events during
+		/// the parse or during tree walks later. Both could be done.
+		/// Not intended for average user!!!  Most people should use
+		/// ParseTreeListener with ParseTreeWalker.
+		/// </remarks>
+		/// <seealso cref="Antlr4.Runtime.Tree.ParseTreeWalker">Antlr4.Runtime.Tree.ParseTreeWalker
+		/// 	</seealso>
+		protected internal IList<ParseTreeListener> _parseListeners;
+
+		/// <summary>Did the recognizer encounter a syntax error?  Track how many.</summary>
+		/// <remarks>Did the recognizer encounter a syntax error?  Track how many.</remarks>
+		protected internal int _syntaxErrors = 0;
+
+		public Parser(TokenStream input)
+		{
+			{
+				_precedenceStack = new IntegerStack();
+				_precedenceStack.Push(0);
+			}
+			SetInputStream(input);
+		}
+
+		/// <summary>reset the parser's state</summary>
+		public virtual void Reset()
+		{
+			if (((TokenStream)GetInputStream()) != null)
+			{
+				((TokenStream)GetInputStream()).Seek(0);
+			}
+			_errHandler.EndErrorCondition(this);
+			_ctx = null;
+			_syntaxErrors = 0;
+			_tracer = null;
+			_precedenceStack.Clear();
+			_precedenceStack.Push(0);
+			ATNSimulator interpreter = GetInterpreter();
+			if (interpreter != null)
+			{
+				interpreter.Reset();
+			}
+		}
+
+		/// <summary>Match current input symbol against ttype.</summary>
+		/// <remarks>
+		/// Match current input symbol against ttype.  Attempt
+		/// single token insertion or deletion error recovery.  If
+		/// that fails, throw MismatchedTokenException.
+		/// </remarks>
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		public virtual Token Match(int ttype)
+		{
+			Token t = GetCurrentToken();
+			if (t.GetType() == ttype)
+			{
+				_errHandler.EndErrorCondition(this);
+				Consume();
+			}
+			else
+			{
+				t = _errHandler.RecoverInline(this);
+				if (_buildParseTrees && t.GetTokenIndex() == -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;
+		}
+
+		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+		public virtual Token MatchWildcard()
+		{
+			Token t = GetCurrentToken();
+			if (t.GetType() > 0)
+			{
+				_errHandler.EndErrorCondition(this);
+				Consume();
+			}
+			else
+			{
+				t = _errHandler.RecoverInline(this);
+				if (_buildParseTrees && t.GetTokenIndex() == -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 RuleContext objects during the parse and hook them up
+		/// using the children list so that it forms a parse tree.
+		/// </summary>
+		/// <remarks>
+		/// Track the RuleContext objects during the parse and hook them up
+		/// using the children list so that it forms a parse tree.
+		/// The RuleContext returned from the start rule represents the root
+		/// of the parse tree.
+		/// To built parse trees, all we have to do is put a hook in setState()
+		/// and enterRule(). In setState(), we add tokens to the current context
+		/// as children. By the time we get to enterRule(), we are already
+		/// in an invoked rule so we add this context as a child of the parent
+		/// (invoking) context. Simple and effective.
+		/// 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.
+		/// When we build parse trees, we are adding all of these contexts to
+		/// somebody's children list. Contexts are then not candidates
+		/// for garbage collection.
+		/// </remarks>
+		public virtual void SetBuildParseTree(bool buildParseTrees)
+		{
+			this._buildParseTrees = buildParseTrees;
+		}
+
+		public virtual bool GetBuildParseTree()
+		{
+			return _buildParseTrees;
+		}
+
+		/// <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
+		/// <code>false</code>
+		/// by default for a newly constructed parser.
+		/// </remarks>
+		/// <param name="trimParseTrees">
+		/// 
+		/// <code>true</code>
+		/// to trim the capacity of the
+		/// <see cref="ParserRuleContext.children">ParserRuleContext.children</see>
+		/// list to its size after a rule is parsed.
+		/// </param>
+		public virtual void SetTrimParseTree(bool trimParseTrees)
+		{
+			if (trimParseTrees)
+			{
+				if (GetTrimParseTree())
+				{
+					return;
+				}
+				AddParseListener(Parser.TrimToSizeListener.Instance);
+			}
+			else
+			{
+				RemoveParseListener(Parser.TrimToSizeListener.Instance);
+			}
+		}
+
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// if the
+		/// <see cref="ParserRuleContext.children">ParserRuleContext.children</see>
+		/// list is trimmed
+		/// using the default
+		/// <see cref="TrimToSizeListener">TrimToSizeListener</see>
+		/// during the parse process.
+		/// </returns>
+		public virtual bool GetTrimParseTree()
+		{
+			if (_parseListeners == null)
+			{
+				return false;
+			}
+			return _parseListeners.Contains(Parser.TrimToSizeListener.Instance);
+		}
+
+		//	public void setTraceATNStates(boolean traceATNStates) {
+		//		this.traceATNStates = traceATNStates;
+		//	}
+		//
+		//	public boolean getTraceATNStates() {
+		//		return traceATNStates;
+		//	}
+		public virtual IList<ParseTreeListener> GetParseListeners()
+		{
+			return _parseListeners;
+		}
+
+		/// <summary>
+		/// Provide a listener that gets notified about token matches,
+		/// and rule entry/exit events DURING the parse.
+		/// </summary>
+		/// <remarks>
+		/// Provide a listener that gets notified about token matches,
+		/// and rule entry/exit events DURING the parse. It's a little bit
+		/// weird for left recursive rule entry events but it's
+		/// deterministic.
+		/// THIS IS ONLY FOR ADVANCED USERS. Please give your
+		/// ParseTreeListener to a ParseTreeWalker instead of giving it to
+		/// the parser!!!!
+		/// </remarks>
+		public virtual void AddParseListener(ParseTreeListener listener)
+		{
+			if (listener == null)
+			{
+				return;
+			}
+			if (_parseListeners == null)
+			{
+				_parseListeners = new AList<ParseTreeListener>();
+			}
+			this._parseListeners.AddItem(listener);
+		}
+
+		public virtual void RemoveParseListener(ParseTreeListener l)
+		{
+			if (l == null)
+			{
+				return;
+			}
+			if (_parseListeners != null)
+			{
+				_parseListeners.Remove(l);
+				if (_parseListeners.IsEmpty())
+				{
+					_parseListeners = null;
+				}
+			}
+		}
+
+		public virtual void RemoveParseListeners()
+		{
+			_parseListeners = null;
+		}
+
+		/// <summary>
+		/// Notify any parse listeners (implemented as ParseTreeListener's)
+		/// of an enter rule event.
+		/// </summary>
+		/// <remarks>
+		/// Notify any parse listeners (implemented as ParseTreeListener's)
+		/// of an enter rule event. This is not involved with
+		/// parse tree walking in any way; it's just reusing the
+		/// ParseTreeListener interface. This is not for the average user.
+		/// </remarks>
+		public virtual void TriggerEnterRuleEvent()
+		{
+			foreach (ParseTreeListener l in _parseListeners)
+			{
+				l.EnterEveryRule(_ctx);
+				_ctx.EnterRule(l);
+			}
+		}
+
+		/// <summary>
+		/// Notify any parse listeners (implemented as ParseTreeListener's)
+		/// of an exit rule event.
+		/// </summary>
+		/// <remarks>
+		/// Notify any parse listeners (implemented as ParseTreeListener's)
+		/// of an exit rule event. This is not involved with
+		/// parse tree walking in any way; it's just reusing the
+		/// ParseTreeListener interface. This is not for the average user.
+		/// </remarks>
+		public virtual void TriggerExitRuleEvent()
+		{
+			// reverse order walk of listeners
+			for (int i = _parseListeners.Count - 1; i >= 0; i--)
+			{
+				ParseTreeListener l = _parseListeners[i];
+				_ctx.ExitRule(l);
+				l.ExitEveryRule(_ctx);
+			}
+		}
+
+		/// <summary>Get number of recognition errors (lexer, parser, tree parser).</summary>
+		/// <remarks>
+		/// Get number of recognition errors (lexer, parser, tree parser).  Each
+		/// recognizer tracks its own number.  So parser and lexer each have
+		/// separate count.  Does not count the spurious errors found between
+		/// an error and next valid token match
+		/// See also reportError()
+		/// </remarks>
+		public virtual int GetNumberOfSyntaxErrors()
+		{
+			return _syntaxErrors;
+		}
+
+		public virtual ANTLRErrorStrategy GetErrorHandler()
+		{
+			return _errHandler;
+		}
+
+		public virtual void SetErrorHandler(ANTLRErrorStrategy handler)
+		{
+			this._errHandler = handler;
+		}
+
+		public override IntStream GetInputStream()
+		{
+			return _input;
+		}
+
+		/// <summary>Set the token stream and reset the parser</summary>
+		public virtual void SetInputStream(TokenStream input)
+		{
+			this._input = null;
+			Reset();
+			this._input = input;
+		}
+
+		/// <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 Token GetCurrentToken()
+		{
+			return _input.Lt(1);
+		}
+
+		public virtual void NotifyErrorListeners(string msg)
+		{
+			NotifyErrorListeners(GetCurrentToken(), msg, null);
+		}
+
+		public virtual void NotifyErrorListeners(Token offendingToken, string msg, RecognitionException
+			 e)
+		{
+			int line = -1;
+			int charPositionInLine = -1;
+			if (offendingToken != null)
+			{
+				line = offendingToken.GetLine();
+				charPositionInLine = offendingToken.GetCharPositionInLine();
+			}
+			ANTLRErrorListener<Token> listener = ((ParserErrorListener)GetErrorListenerDispatch
+				());
+			listener.SyntaxError(this, offendingToken, line, charPositionInLine, msg, e);
+		}
+
+		/// <summary>Consume the current symbol and return it.</summary>
+		/// <remarks>
+		/// Consume the current symbol and return it. E.g., given the following
+		/// input with A being the current lookahead symbol:
+		/// A B
+		/// ^
+		/// this function moves the cursor to B and returns A.
+		/// If the parser is creating parse trees, the current symbol
+		/// would also be added as a child to the current context (node).
+		/// Trigger listener events if there's a listener.
+		/// </remarks>
+		public virtual Token Consume()
+		{
+			Token o = GetCurrentToken();
+			if (o.GetType() != Eof)
+			{
+				((TokenStream)GetInputStream()).Consume();
+			}
+			bool hasListener = _parseListeners != null && !_parseListeners.IsEmpty();
+			if (_buildParseTrees || hasListener)
+			{
+				if (_errHandler.InErrorRecoveryMode(this))
+				{
+					ErrorNode node = _ctx.AddErrorNode(o);
+					if (_parseListeners != null)
+					{
+						foreach (ParseTreeListener listener in _parseListeners)
+						{
+							listener.VisitErrorNode(node);
+						}
+					}
+				}
+				else
+				{
+					TerminalNode node = _ctx.AddChild(o);
+					if (_parseListeners != null)
+					{
+						foreach (ParseTreeListener 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.
+		/// This occurs after the new context has been pushed. Access field
+		/// _ctx get the current context.
+		/// This is flexible because users do not have to regenerate parsers
+		/// to get trace facilities.
+		/// </remarks>
+		public virtual void EnterRule(ParserRuleContext localctx, int state, int ruleIndex
+			)
+		{
+			SetState(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)
+		{
+			SetState(state);
+			if (_buildParseTrees)
+			{
+				ParserRuleContext factoredContext = (ParserRuleContext)_ctx.GetChild(_ctx.GetChildCount
+					() - 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();
+			}
+			SetState(_ctx.invokingState);
+			_ctx = (ParserRuleContext)_ctx.parent;
+		}
+
+		public virtual void EnterOuterAlt(ParserRuleContext localctx, int 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;
+			_ctx.altNum = altNum;
+		}
+
+		public virtual void EnterRecursionRule(ParserRuleContext localctx, int ruleIndex, 
+			int precedence)
+		{
+			_precedenceStack.Push(precedence);
+			_ctx = localctx;
+			_ctx.start = _input.Lt(1);
+			if (_parseListeners != null)
+			{
+				TriggerEnterRuleEvent();
+			}
+		}
+
+		// simulates rule entry for left-recursive rules
+		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.Pop();
+			_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.AddChild(retctx);
+			}
+		}
+
+		// add return ctx into invoking rule's tree
+		public virtual ParserRuleContext GetInvokingContext(int ruleIndex)
+		{
+			ParserRuleContext p = _ctx;
+			while (p != null)
+			{
+				if (p.GetRuleIndex() == ruleIndex)
+				{
+					return p;
+				}
+				p = (ParserRuleContext)p.parent;
+			}
+			return null;
+		}
+
+		public virtual ParserRuleContext GetContext()
+		{
+			return _ctx;
+		}
+
+		public override bool Precpred(RuleContext localctx, int precedence)
+		{
+			return precedence >= _precedenceStack.Peek();
+		}
+
+		public override ANTLRErrorListener<Token> GetErrorListenerDispatch()
+		{
+			return new ProxyParserErrorListener(GetErrorListeners());
+		}
+
+		public virtual bool InContext(string context)
+		{
+			// TODO: useful in parser?
+			return false;
+		}
+
+		public virtual bool IsExpectedToken(int symbol)
+		{
+			//   		return getInterpreter().atn.nextTokens(_ctx);
+			ATN atn = GetInterpreter().atn;
+			ParserRuleContext ctx = _ctx;
+			ATNState s = atn.states[GetState()];
+			IntervalSet following = atn.NextTokens(s);
+			if (following.Contains(symbol))
+			{
+				return true;
+			}
+			//        System.out.println("following "+s+"="+following);
+			if (!following.Contains(Token.Epsilon))
+			{
+				return false;
+			}
+			while (ctx != null && ctx.invokingState >= 0 && following.Contains(Token.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(Token.Epsilon) && symbol == Token.Eof)
+			{
+				return true;
+			}
+			return false;
+		}
+
+		/// <summary>
+		/// Compute the set of valid tokens reachable from the current
+		/// position in the parse.
+		/// </summary>
+		/// <remarks>
+		/// Compute the set of valid tokens reachable from the current
+		/// position in the parse.
+		/// </remarks>
+		public virtual IntervalSet GetExpectedTokens()
+		{
+			ATN atn = GetInterpreter().atn;
+			ParserRuleContext ctx = _ctx;
+			ATNState s = atn.states[GetState()];
+			IntervalSet following = atn.NextTokens(s);
+			//        System.out.println("following "+s+"="+following);
+			if (!following.Contains(Token.Epsilon))
+			{
+				return following;
+			}
+			IntervalSet expected = new IntervalSet();
+			expected.AddAll(following);
+			expected.Remove(Token.Epsilon);
+			while (ctx != null && ctx.invokingState >= 0 && following.Contains(Token.Epsilon)
+				)
+			{
+				ATNState invokingState = atn.states[ctx.invokingState];
+				RuleTransition rt = (RuleTransition)invokingState.Transition(0);
+				following = atn.NextTokens(rt.followState);
+				expected.AddAll(following);
+				expected.Remove(Token.Epsilon);
+				ctx = (ParserRuleContext)ctx.parent;
+			}
+			if (following.Contains(Token.Epsilon))
+			{
+				expected.Add(Token.Eof);
+			}
+			return expected;
+		}
+
+		public virtual IntervalSet GetExpectedTokensWithinCurrentRule()
+		{
+			ATN atn = GetInterpreter().atn;
+			ATNState s = atn.states[GetState()];
+			return atn.NextTokens(s);
+		}
+
+		//	/** Compute the set of valid tokens reachable from the current
+		//	 *  position in the parse.
+		//	 */
+		//	public IntervalSet nextTokens(@NotNull RuleContext ctx) {
+		//		ATN atn = getInterpreter().atn;
+		//		ATNState s = atn.states.get(ctx.s);
+		//		if ( s == null ) return null;
+		//		return atn.nextTokens(s, ctx);
+		//	}
+		public virtual ParserRuleContext GetRuleContext()
+		{
+			return _ctx;
+		}
+
+		/// <summary>
+		/// Return List<String> of the rule names in your parser instance
+		/// leading up to a call to the current rule.
+		/// </summary>
+		/// <remarks>
+		/// Return List<String> 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 IList<string> GetRuleInvocationStack(RuleContext p)
+		{
+			string[] ruleNames = GetRuleNames();
+			IList<string> stack = new AList<string>();
+			while (p != null)
+			{
+				// compute what follows who invoked us
+				int ruleIndex = p.GetRuleIndex();
+				if (ruleIndex < 0)
+				{
+					stack.AddItem("n/a");
+				}
+				else
+				{
+					stack.AddItem(ruleNames[ruleIndex]);
+				}
+				p = p.parent;
+			}
+			return stack;
+		}
+
+		/// <summary>For debugging and other purposes</summary>
+		public virtual IList<string> GetDFAStrings()
+		{
+			IList<string> s = new AList<string>();
+			for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
+			{
+				DFA dfa = _interp.atn.decisionToDFA[d];
+				s.AddItem(dfa.ToString(GetTokenNames(), GetRuleNames()));
+			}
+			return s;
+		}
+
+		/// <summary>For debugging and other purposes</summary>
+		public virtual void DumpDFA()
+		{
+			bool seenOne = false;
+			for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
+			{
+				DFA dfa = _interp.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(GetTokenNames(), GetRuleNames()));
+					seenOne = true;
+				}
+			}
+		}
+
+		public virtual string GetSourceName()
+		{
+			return _input.GetSourceName();
+		}
+
+		/// <summary>A convenience method for use most often with template rewrites.</summary>
+		/// <remarks>
+		/// A convenience method for use most often with template rewrites.
+		/// Convert a List<Token> to List<String>
+		/// </remarks>
+		public virtual IList<string> ToStrings<_T0>(IList<_T0> tokens) where _T0:Token
+		{
+			if (tokens == null)
+			{
+				return null;
+			}
+			IList<string> strings = new AList<string>(tokens.Count);
+			for (int i = 0; i < tokens.Count; i++)
+			{
+				strings.AddItem(tokens[i].GetText());
+			}
+			return strings;
+		}
+
+		/// <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 void SetTrace(bool trace)
+		{
+			if (!trace)
+			{
+				RemoveParseListener(_tracer);
+				_tracer = null;
+			}
+			else
+			{
+				if (_tracer != null)
+				{
+					RemoveParseListener(_tracer);
+				}
+				else
+				{
+					_tracer = new Parser.TraceListener(this);
+				}
+				AddParseListener(_tracer);
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/ParserErrorListener.cs b/Antlr4.Runtime/ParserErrorListener.cs
new file mode 100644
index 000000000..484647218
--- /dev/null
+++ b/Antlr4.Runtime/ParserErrorListener.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 Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>How to emit recognition errors</summary>
+	public interface ParserErrorListener : ANTLRErrorListener<Token>
+	{
+		/// <summary>
+		/// Called when the parser detects a true ambiguity: an input sequence can be matched
+		/// literally by two or more pass through the grammar.
+		/// </summary>
+		/// <remarks>
+		/// Called when the parser detects a true ambiguity: an input sequence can be matched
+		/// literally by two or more pass through the grammar. ANTLR resolves the ambiguity in
+		/// favor of the alternative appearing first in the grammar. The start and stop index are
+		/// zero-based absolute indices into the token stream. ambigAlts is a set of alternative numbers
+		/// that can match the input sequence. This method is only called when we are parsing with
+		/// full context.
+		/// </remarks>
+		void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet
+			 ambigAlts, ATNConfigSet configs);
+
+		void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int 
+			stopIndex, SimulatorState initialState);
+
+		/// <summary>
+		/// Called by the parser when it find a conflict that is resolved by retrying the parse
+		/// with full context.
+		/// </summary>
+		/// <remarks>
+		/// Called by the parser when it find a conflict that is resolved by retrying the parse
+		/// with full context. This is not a warning; it simply notifies you that your grammar
+		/// is more complicated than Strong LL can handle. The parser moved up to full context
+		/// parsing for that input sequence.
+		/// </remarks>
+		void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex
+			, SimulatorState acceptState);
+	}
+}
diff --git a/Antlr4.Runtime/ParserRuleContext.cs b/Antlr4.Runtime/ParserRuleContext.cs
new file mode 100644
index 000000000..e24e1bc2e
--- /dev/null
+++ b/Antlr4.Runtime/ParserRuleContext.cs
@@ -0,0 +1,382 @@
+/*
+ * [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.Tree;
+using Sharpen;
+
+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<ParseTree> 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>
+		public Token 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>
+		public Token stop;
+
+		/// <summary>Set during parsing to identify which alt of rule parser is in.</summary>
+		/// <remarks>Set during parsing to identify which alt of rule parser is in.</remarks>
+		public int altNum;
+
+		/// <summary>The exception which forced this rule to return.</summary>
+		/// <remarks>
+		/// The exception which forced this rule to return. If the rule successfully
+		/// completed, this is
+		/// <code>null</code>
+		/// .
+		/// </remarks>
+		public RecognitionException exception;
+
+		public ParserRuleContext()
+		{
+		}
+
+		//	public List<Integer> states;
+		public static Antlr4.Runtime.ParserRuleContext EmptyContext()
+		{
+			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(ParseTreeListener listener)
+		{
+		}
+
+		public virtual void ExitRule(ParseTreeListener listener)
+		{
+		}
+
+		/// <summary>Does not set parent link; other add methods do that</summary>
+		public virtual void AddChild(TerminalNode t)
+		{
+			if (children == null)
+			{
+				children = new AList<ParseTree>();
+			}
+			children.AddItem(t);
+		}
+
+		public virtual void AddChild(RuleContext ruleInvocation)
+		{
+			if (children == null)
+			{
+				children = new AList<ParseTree>();
+			}
+			children.AddItem(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.Remove(children.Count - 1);
+			}
+		}
+
+		//	public void trace(int s) {
+		//		if ( states==null ) states = new ArrayList<Integer>();
+		//		states.add(s);
+		//	}
+		public virtual TerminalNode AddChild(Token matchedToken)
+		{
+			TerminalNodeImpl t = new TerminalNodeImpl(matchedToken);
+			AddChild(t);
+			t.parent = this;
+			return t;
+		}
+
+		public virtual ErrorNode AddErrorNode(Token badToken)
+		{
+			ErrorNodeImpl t = new ErrorNodeImpl(badToken);
+			AddChild(t);
+			t.parent = this;
+			return t;
+		}
+
+		public override RuleContext GetParent()
+		{
+			return (Antlr4.Runtime.ParserRuleContext)base.GetParent();
+		}
+
+		public override ParseTree GetChild(int i)
+		{
+			return children != null && i >= 0 && i < children.Count ? children[i] : null;
+		}
+
+		public virtual T GetChild<T, _T1>(Type<_T1> ctxType, int i) where T:ParseTree where 
+			_T1:T
+		{
+			if (children == null || i < 0 || i >= children.Count)
+			{
+				return null;
+			}
+			int j = -1;
+			// what element have we found with ctxType?
+			foreach (ParseTree o in children)
+			{
+				if (ctxType.IsInstanceOfType(o))
+				{
+					j++;
+					if (j == i)
+					{
+						return ctxType.Cast(o);
+					}
+				}
+			}
+			return null;
+		}
+
+		public virtual TerminalNode 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 (ParseTree o in children)
+			{
+				if (o is TerminalNode)
+				{
+					TerminalNode tnode = (TerminalNode)o;
+					Token symbol = tnode.GetSymbol();
+					if (symbol.GetType() == ttype)
+					{
+						j++;
+						if (j == i)
+						{
+							return tnode;
+						}
+					}
+				}
+			}
+			return null;
+		}
+
+		public virtual IList<TerminalNode> GetTokens(int ttype)
+		{
+			if (children == null)
+			{
+				return Sharpen.Collections.EmptyList();
+			}
+			IList<TerminalNode> tokens = null;
+			foreach (ParseTree o in children)
+			{
+				if (o is TerminalNode)
+				{
+					TerminalNode tnode = (TerminalNode)o;
+					Token symbol = tnode.GetSymbol();
+					if (symbol.GetType() == ttype)
+					{
+						if (tokens == null)
+						{
+							tokens = new AList<TerminalNode>();
+						}
+						tokens.AddItem(tnode);
+					}
+				}
+			}
+			if (tokens == null)
+			{
+				return Sharpen.Collections.EmptyList();
+			}
+			return tokens;
+		}
+
+		public virtual T GetRuleContext<T, _T1>(Type<_T1> ctxType, int i) where T:Antlr4.Runtime.ParserRuleContext
+			 where _T1:T
+		{
+			return GetChild(ctxType, i);
+		}
+
+		public virtual IList<T> GetRuleContexts<T, _T1>(Type<_T1> ctxType) where T:Antlr4.Runtime.ParserRuleContext
+			 where _T1:T
+		{
+			if (children == null)
+			{
+				return Sharpen.Collections.EmptyList();
+			}
+			IList<T> contexts = null;
+			foreach (ParseTree o in children)
+			{
+				if (ctxType.IsInstanceOfType(o))
+				{
+					if (contexts == null)
+					{
+						contexts = new AList<T>();
+					}
+					contexts.AddItem(ctxType.Cast(o));
+				}
+			}
+			if (contexts == null)
+			{
+				return Sharpen.Collections.EmptyList();
+			}
+			return contexts;
+		}
+
+		public override int GetChildCount()
+		{
+			return children != null ? children.Count : 0;
+		}
+
+		public override Interval GetSourceInterval()
+		{
+			if (start == null || stop == null)
+			{
+				return Interval.Invalid;
+			}
+			return Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex());
+		}
+
+		public virtual Token GetStart()
+		{
+			return start;
+		}
+
+		public virtual Token GetStop()
+		{
+			return stop;
+		}
+
+		/// <summary>Used for rule context info debugging during parse-time, not so much for ATN debugging
+		/// 	</summary>
+		public virtual string ToInfoString(Parser recognizer)
+		{
+			IList<string> rules = recognizer.GetRuleInvocationStack(this);
+			Sharpen.Collections.Reverse(rules);
+			return "ParserRuleContext" + rules + "{" + "altNum=" + altNum + ", start=" + start
+				 + ", stop=" + stop + '}';
+		}
+	}
+}
diff --git a/Antlr4.Runtime/ProxyErrorListener.cs b/Antlr4.Runtime/ProxyErrorListener.cs
new file mode 100644
index 000000000..7da11c1fe
--- /dev/null
+++ b/Antlr4.Runtime/ProxyErrorListener.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 System.Collections.Generic;
+using Antlr4.Runtime;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <author>Sam Harwell</author>
+	public class ProxyErrorListener<Symbol> : ANTLRErrorListener<Symbol>
+	{
+		private readonly ICollection<ANTLRErrorListener<Symbol>> delegates;
+
+		public ProxyErrorListener(ICollection<ANTLRErrorListener<Symbol>> delegates)
+		{
+			this.delegates = delegates;
+		}
+
+		protected internal virtual ICollection<ANTLRErrorListener<Symbol>> GetDelegates()
+		{
+			return delegates;
+		}
+
+		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
+			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
+			Symbol
+		{
+			foreach (ANTLRErrorListener<Symbol> listener in delegates)
+			{
+				listener.SyntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, 
+					e);
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/ProxyParserErrorListener.cs b/Antlr4.Runtime/ProxyParserErrorListener.cs
new file mode 100644
index 000000000..4025d470b
--- /dev/null
+++ b/Antlr4.Runtime/ProxyParserErrorListener.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 System.Collections.Generic;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Atn;
+using Antlr4.Runtime.Dfa;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <author>Sam Harwell</author>
+	public class ProxyParserErrorListener : ProxyErrorListener<Token>, ParserErrorListener
+	{
+		public ProxyParserErrorListener(ICollection<ANTLRErrorListener<Token>> delegates)
+			 : base(delegates)
+		{
+		}
+
+		public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
+			 stopIndex, BitSet ambigAlts, ATNConfigSet configs)
+		{
+			foreach (ANTLRErrorListener<Token> listener in GetDelegates())
+			{
+				if (!(listener is ParserErrorListener))
+				{
+					continue;
+				}
+				ParserErrorListener parserErrorListener = (ParserErrorListener)listener;
+				parserErrorListener.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, ambigAlts
+					, configs);
+			}
+		}
+
+		public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
+			, int stopIndex, SimulatorState initialState)
+		{
+			foreach (ANTLRErrorListener<Token> listener in GetDelegates())
+			{
+				if (!(listener is ParserErrorListener))
+				{
+					continue;
+				}
+				ParserErrorListener parserErrorListener = (ParserErrorListener)listener;
+				parserErrorListener.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex
+					, initialState);
+			}
+		}
+
+		public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
+			, int stopIndex, SimulatorState acceptState)
+		{
+			foreach (ANTLRErrorListener<Token> listener in GetDelegates())
+			{
+				if (!(listener is ParserErrorListener))
+				{
+					continue;
+				}
+				ParserErrorListener parserErrorListener = (ParserErrorListener)listener;
+				parserErrorListener.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex
+					, acceptState);
+			}
+		}
+	}
+}
diff --git a/Antlr4.Runtime/RecognitionException.cs b/Antlr4.Runtime/RecognitionException.cs
new file mode 100644
index 000000000..586dd1c5b
--- /dev/null
+++ b/Antlr4.Runtime/RecognitionException.cs
@@ -0,0 +1,155 @@
+/*
+ * [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 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 : RuntimeException
+	{
+		private const long serialVersionUID = -3861826954750022374L;
+
+		/// <summary>Who threw the exception?</summary>
+		private Recognizer<object, object> recognizer;
+
+		private RuleContext ctx;
+
+		private IntStream input;
+
+		/// <summary>The current Token when an error occurred.</summary>
+		/// <remarks>
+		/// The current Token when an error occurred.  Since not all streams
+		/// can retrieve the ith Token, we have to track the Token object.
+		/// For parsers.  Even when it's a tree parser, token might be set.
+		/// </remarks>
+		private Token offendingToken;
+
+		private int offendingState;
+
+		public RecognitionException(Lexer lexer, CharStream input)
+		{
+			// TODO: make a dummy recognizer for the interpreter to use?
+			// Next two (ctx,input) should be what is in recognizer, but
+			// won't work when interpreting
+			this.recognizer = lexer;
+			this.input = input;
+		}
+
+		public RecognitionException(Recognizer<Token, object> recognizer, IntStream input
+			, ParserRuleContext ctx)
+		{
+			this.recognizer = recognizer;
+			this.input = input;
+			this.ctx = ctx;
+			if (recognizer != null)
+			{
+				this.offendingState = recognizer.GetState();
+			}
+		}
+
+		public RecognitionException(string message, Recognizer<Token, object> recognizer, 
+			IntStream input, ParserRuleContext ctx) : base(message)
+		{
+			this.recognizer = recognizer;
+			this.input = input;
+			this.ctx = ctx;
+			if (recognizer != null)
+			{
+				this.offendingState = recognizer.GetState();
+			}
+		}
+
+		/// <summary>
+		/// Where was the parser in the ATN when the error occurred?
+		/// For No viable alternative exceptions, this is the decision state number.
+		/// </summary>
+		/// <remarks>
+		/// Where was the parser in the ATN when the error occurred?
+		/// For No viable alternative exceptions, this is the decision state number.
+		/// For others, it is the state whose emanating edge we couldn't match.
+		/// This will help us tie into the grammar and syntax diagrams in
+		/// ANTLRWorks v2.
+		/// </remarks>
+		public virtual int GetOffendingState()
+		{
+			return offendingState;
+		}
+
+		protected internal void SetOffendingState(int offendingState)
+		{
+			this.offendingState = offendingState;
+		}
+
+		public virtual IntervalSet GetExpectedTokens()
+		{
+			// TODO: do we really need this type check?
+			if (recognizer is Parser)
+			{
+				return ((Parser)recognizer).GetExpectedTokens();
+			}
+			return null;
+		}
+
+		public virtual RuleContext GetCtx()
+		{
+			return ctx;
+		}
+
+		public virtual IntStream GetInputStream()
+		{
+			return input;
+		}
+
+		public virtual Token GetOffendingToken()
+		{
+			return offendingToken;
+		}
+
+		protected internal void SetOffendingToken(Token offendingToken)
+		{
+			this.offendingToken = offendingToken;
+		}
+
+		public virtual Recognizer<object, object> GetRecognizer()
+		{
+			return recognizer;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Recognizer.cs b/Antlr4.Runtime/Recognizer.cs
new file mode 100644
index 000000000..30189dbb3
--- /dev/null
+++ b/Antlr4.Runtime/Recognizer.cs
@@ -0,0 +1,219 @@
+/*
+ * [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.Misc;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	public abstract class Recognizer<Symbol, ATNInterpreter> where ATNInterpreter:ATNSimulator
+	{
+		public const int Eof = -1;
+
+		private sealed class _CopyOnWriteArrayList_49 : CopyOnWriteArrayList<ANTLRErrorListener
+			<Symbol>>
+		{
+			public _CopyOnWriteArrayList_49()
+			{
+				{
+					this.AddItem(ConsoleErrorListener.Instance);
+				}
+			}
+		}
+
+		[NotNull]
+		private IList<ANTLRErrorListener<Symbol>> _listeners = new _CopyOnWriteArrayList_49
+			();
+
+		protected internal 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[] GetTokenNames();
+
+		public abstract string[] GetRuleNames();
+
+		/// <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 GetGrammarFileName();
+
+		public virtual ATN GetATN()
+		{
+			return _interp.atn;
+		}
+
+		public virtual ATNInterpreter GetInterpreter()
+		{
+			return _interp;
+		}
+
+		public virtual void SetInterpreter(ATNInterpreter interpreter)
+		{
+			_interp = interpreter;
+		}
+
+		/// <summary>What is the error header, normally line/character position information?</summary>
+		public virtual string GetErrorHeader(RecognitionException e)
+		{
+			int line = e.GetOffendingToken().GetLine();
+			int charPositionInLine = e.GetOffendingToken().GetCharPositionInLine();
+			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>
+		public virtual string GetTokenErrorDisplay(Token t)
+		{
+			if (t == null)
+			{
+				return "<no token>";
+			}
+			string s = t.GetText();
+			if (s == null)
+			{
+				if (t.GetType() == Token.Eof)
+				{
+					s = "<EOF>";
+				}
+				else
+				{
+					s = "<" + t.GetType() + ">";
+				}
+			}
+			s = s.ReplaceAll("\n", "\\\\n");
+			s = s.ReplaceAll("\r", "\\\\r");
+			s = s.ReplaceAll("\t", "\\\\t");
+			return "'" + s + "'";
+		}
+
+		/// <exception cref="System.ArgumentNullException">
+		/// if
+		/// <code>listener</code>
+		/// is
+		/// <code>null</code>
+		/// .
+		/// </exception>
+		public virtual void AddErrorListener<_T0>(ANTLRErrorListener<_T0> listener)
+		{
+			Args.NotNull("listener", listener);
+			_listeners.AddItem(listener);
+		}
+
+		public virtual void RemoveErrorListener<_T0>(ANTLRErrorListener<_T0> listener)
+		{
+			_listeners.Remove(listener);
+		}
+
+		public virtual void RemoveErrorListeners()
+		{
+			_listeners.Clear();
+		}
+
+		[NotNull]
+		public virtual IList<ANTLRErrorListener<Symbol>> GetErrorListeners()
+		{
+			return new AList<ANTLRErrorListener<Symbol>>(_listeners);
+		}
+
+		public virtual ANTLRErrorListener<Symbol> GetErrorListenerDispatch()
+		{
+			return new ProxyErrorListener<Symbol>(GetErrorListeners());
+		}
+
+		// 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)
+		{
+		}
+
+		public int GetState()
+		{
+			return _stateNumber;
+		}
+
+		/// <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 void SetState(int atnState)
+		{
+			//		System.err.println("setState "+atnState);
+			_stateNumber = atnState;
+		}
+
+		//		if ( traceATNStates ) _ctx.trace(atnState);
+		public abstract IntStream GetInputStream();
+	}
+}
diff --git a/Antlr4.Runtime/RuleContext.cs b/Antlr4.Runtime/RuleContext.cs
new file mode 100644
index 000000000..f64af55af
--- /dev/null
+++ b/Antlr4.Runtime/RuleContext.cs
@@ -0,0 +1,324 @@
+/*
+ * [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.Misc;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Gui;
+using Javax.Swing;
+using Sharpen;
+
+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 and tree parsers, we use the subclass
+	/// ParserRuleContext.
+	/// </remarks>
+	/// <seealso cref="ParserRuleContext">ParserRuleContext</seealso>
+	public class RuleContext : RuleNode
+	{
+		/// <summary>What context invoked this rule?</summary>
+		public 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()
+		{
+			return invokingState == -1;
+		}
+
+		// satisfy the ParseTree / SyntaxTree interface
+		public virtual Interval GetSourceInterval()
+		{
+			return Interval.Invalid;
+		}
+
+		public virtual Antlr4.Runtime.RuleContext GetRuleContext()
+		{
+			return this;
+		}
+
+		public virtual Antlr4.Runtime.RuleContext GetParent()
+		{
+			return parent;
+		}
+
+		public virtual Antlr4.Runtime.RuleContext GetPayload()
+		{
+			return this;
+		}
+
+		/// <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 (GetChildCount() == 0)
+			{
+				return string.Empty;
+			}
+			StringBuilder builder = new StringBuilder();
+			for (int i = 0; i < GetChildCount(); i++)
+			{
+				builder.Append(GetChild(i).GetText());
+			}
+			return builder.ToString();
+		}
+
+		public virtual int GetRuleIndex()
+		{
+			return -1;
+		}
+
+		public virtual ParseTree GetChild(int i)
+		{
+			return null;
+		}
+
+		public virtual int GetChildCount()
+		{
+			return 0;
+		}
+
+		public virtual T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor) where _T1:T
+		{
+			return visitor.VisitChildren(this);
+		}
+
+		/// <summary>Call this method to view a parse tree in a dialog box visually.</summary>
+		/// <remarks>Call this method to view a parse tree in a dialog box visually.</remarks>
+		public virtual Future<JDialog> Inspect(Parser parser)
+		{
+			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
+				null;
+			return Inspect(ruleNames);
+		}
+
+		public virtual Future<JDialog> Inspect(IList<string> ruleNames)
+		{
+			TreeViewer viewer = new TreeViewer(ruleNames, this);
+			return viewer.Open();
+		}
+
+		/// <summary>Save this tree in a postscript file</summary>
+		/// <exception cref="System.IO.IOException"></exception>
+		/// <exception cref="Javax.Print.PrintException"></exception>
+		public virtual void Save(Parser parser, string fileName)
+		{
+			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
+				null;
+			Save(ruleNames, fileName);
+		}
+
+		/// <summary>Save this tree in a postscript file using a particular font name and size
+		/// 	</summary>
+		/// <exception cref="System.IO.IOException"></exception>
+		public virtual void Save(Parser parser, string fileName, string fontName, int fontSize
+			)
+		{
+			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
+				null;
+			Save(ruleNames, fileName, fontName, fontSize);
+		}
+
+		/// <summary>Save this tree in a postscript file</summary>
+		/// <exception cref="System.IO.IOException"></exception>
+		/// <exception cref="Javax.Print.PrintException"></exception>
+		public virtual void Save(IList<string> ruleNames, string fileName)
+		{
+			Trees.WritePS(this, ruleNames, fileName);
+		}
+
+		/// <summary>Save this tree in a postscript file using a particular font name and size
+		/// 	</summary>
+		/// <exception cref="System.IO.IOException"></exception>
+		public virtual void Save(IList<string> ruleNames, string fileName, string fontName
+			, int fontSize)
+		{
+			Trees.WritePS(this, ruleNames, fileName, fontName, fontSize);
+		}
+
+		/// <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<_T0>(Recognizer<_T0> 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<_T0>(Recognizer<_T0> recog, Antlr4.Runtime.RuleContext
+			 stop)
+		{
+			string[] ruleNames = recog != null ? recog.GetRuleNames() : 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.GetRuleIndex();
+					string ruleName = ruleIndex >= 0 && ruleIndex < ruleNames.Count ? ruleNames[ruleIndex
+						] : Sharpen.Extensions.ToString(ruleIndex);
+					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/Antlr4.Runtime/Token.cs b/Antlr4.Runtime/Token.cs
new file mode 100644
index 000000000..cd3cb4c25
--- /dev/null
+++ b/Antlr4.Runtime/Token.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 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 abstract class Token
+	{
+		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 = IntStream.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>Get the text of the token</summary>
+		public abstract string GetText();
+
+		/// <summary>Get the token type of the token</summary>
+		public abstract int GetType();
+
+		/// <summary>
+		/// The line number on which the 1st character of this token was matched,
+		/// line=1..n
+		/// </summary>
+		public abstract int GetLine();
+
+		/// <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>
+		public abstract int GetCharPositionInLine();
+
+		/// <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>
+		public abstract int GetChannel();
+
+		/// <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>
+		public abstract int GetTokenIndex();
+
+		/// <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>
+		public abstract int GetStartIndex();
+
+		/// <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>
+		public abstract int GetStopIndex();
+
+		/// <summary>
+		/// Gets the
+		/// <see cref="TokenSource">TokenSource</see>
+		/// which created this token.
+		/// </summary>
+		public abstract TokenSource GetTokenSource();
+
+		/// <summary>
+		/// Gets the
+		/// <see cref="CharStream">CharStream</see>
+		/// from which this token was derived.
+		/// </summary>
+		public abstract CharStream GetInputStream();
+	}
+}
diff --git a/Antlr4.Runtime/TokenFactory.cs b/Antlr4.Runtime/TokenFactory.cs
new file mode 100644
index 000000000..e77c4f7ad
--- /dev/null
+++ b/Antlr4.Runtime/TokenFactory.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;
+using Antlr4.Runtime;
+using 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 TokenFactory
+	{
+		/// <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>
+		Token Create<_T0>(Tuple<_T0> source, int type, string text, int channel, int start
+			, int stop, int line, int charPositionInLine) where _T0:TokenSource;
+
+		/// <summary>Generically useful</summary>
+		Token Create(int type, string text);
+	}
+}
diff --git a/Antlr4.Runtime/TokenSource.cs b/Antlr4.Runtime/TokenSource.cs
new file mode 100644
index 000000000..0e5686b27
--- /dev/null
+++ b/Antlr4.Runtime/TokenSource.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;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// A source of tokens must provide a sequence of tokens via nextToken()
+	/// and also must reveal it's source of characters; CommonToken's text is
+	/// computed from a CharStream; it only store indices into the char stream.
+	/// </summary>
+	/// <remarks>
+	/// A source of tokens must provide a sequence of tokens via nextToken()
+	/// and also must reveal it's source of characters; CommonToken's text is
+	/// computed from a CharStream; it only store indices into the char stream.
+	/// 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 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.
+	/// </remarks>
+	public interface TokenSource
+	{
+		/// <summary>Return a Token object from your input stream (usually a CharStream).</summary>
+		/// <remarks>
+		/// Return a Token object from your input stream (usually a CharStream).
+		/// 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.
+		/// </remarks>
+		Token NextToken();
+
+		int GetLine();
+
+		int GetCharPositionInLine();
+
+		/// <summary>
+		/// From what character stream was this token created?  You don't have to
+		/// implement but it's nice to know where a Token comes from if you have
+		/// include files etc...
+		/// </summary>
+		/// <remarks>
+		/// From what character stream was this token created?  You don't have to
+		/// implement but it's nice to know where a Token comes from if you have
+		/// include files etc... on the input.
+		/// </remarks>
+		CharStream GetInputStream();
+
+		/// <summary>
+		/// Where are you getting tokens from? normally the implication will simply
+		/// ask lexers input stream.
+		/// </summary>
+		/// <remarks>
+		/// Where are you getting tokens from? normally the implication will simply
+		/// ask lexers input stream.
+		/// </remarks>
+		string GetSourceName();
+
+		/// <summary>Gets the factory used for constructing tokens.</summary>
+		/// <remarks>Gets the factory used for constructing tokens.</remarks>
+		TokenFactory GetTokenFactory();
+
+		/// <summary>Optional method that lets users set factory in lexer or other source</summary>
+		void SetTokenFactory(TokenFactory factory);
+	}
+}
diff --git a/Antlr4.Runtime/TokenStream.cs b/Antlr4.Runtime/TokenStream.cs
new file mode 100644
index 000000000..29fd1cd22
--- /dev/null
+++ b/Antlr4.Runtime/TokenStream.cs
@@ -0,0 +1,245 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	/// <summary>
+	/// An
+	/// <see cref="IntStream">IntStream</see>
+	/// whose symbols are
+	/// <see cref="Token">Token</see>
+	/// instances.
+	/// </summary>
+	public interface TokenStream : IntStream
+	{
+		/// <summary>
+		/// Get the
+		/// <see cref="Token">Token</see>
+		/// instance associated with the value returned by
+		/// <see cref="IntStream.La(int)">LA(k)</see>
+		/// . This method has the same pre- and post-conditions as
+		/// <see cref="IntStream.La(int)">IntStream.La(int)</see>
+		/// . In addition, when the preconditions of this method
+		/// are met, the return value is non-null and the value of
+		/// <code>LT(k).getType()==LA(k)</code>
+		/// .
+		/// </summary>
+		/// <seealso cref="IntStream.La(int)">IntStream.La(int)</seealso>
+		[NotNull]
+		Token Lt(int k);
+
+		/// <summary>
+		/// Gets the
+		/// <see cref="Token">Token</see>
+		/// at the specified
+		/// <code>index</code>
+		/// 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="IntStream.Seek(int)">IntStream.Seek(int)</see>
+		/// . If the behavior of
+		/// <code>seek(index)</code>
+		/// is
+		/// unspecified for the current state and given
+		/// <code>index</code>
+		/// , then the
+		/// behavior of this method is also unspecified.
+		/// <p/>
+		/// The symbol referred to by
+		/// <code>index</code>
+		/// differs from
+		/// <code>seek()</code>
+		/// only
+		/// in the case of filtering streams where
+		/// <code>index</code>
+		/// lies before the end
+		/// of the stream. Unlike
+		/// <code>seek()</code>
+		/// , this method does not adjust
+		/// <code>index</code>
+		/// to point to a non-ignored symbol.
+		/// </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>
+		[NotNull]
+		Token Get(int i);
+
+		/// <summary>
+		/// Gets the underlying
+		/// <see cref="TokenSource">TokenSource</see>
+		/// which provides tokens for this
+		/// stream.
+		/// </summary>
+		[NotNull]
+		TokenSource GetTokenSource();
+
+		/// <summary>
+		/// Return the text of all tokens within the specified
+		/// <code>interval</code>
+		/// . This
+		/// method behaves like the following code (including potential exceptions
+		/// for violating preconditions of
+		/// <see cref="Get(int)">Get(int)</see>
+		/// , 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
+		/// <code>interval</code>
+		/// is
+		/// <code>null</code>
+		/// </exception>
+		[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="IntStream.Size()">IntStream.Size()</see>
+		/// and
+		/// <see cref="GetText(Antlr4.Runtime.Misc.Interval)">GetText(Antlr4.Runtime.Misc.Interval)
+		/// 	</see>
+		/// , 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>
+		[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)">GetText(Antlr4.Runtime.Misc.Interval)
+		/// 	</see>
+		/// , but may be
+		/// optimized by the specific implementation.
+		/// </p>
+		/// If
+		/// <code>ctx.getSourceInterval()</code>
+		/// does not return a valid interval of
+		/// tokens provided by this stream, the behavior is unspecified.
+		/// <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
+		/// <code>ctx</code>
+		/// .
+		/// </returns>
+		[NotNull]
+		string GetText(RuleContext ctx);
+
+		/// <summary>
+		/// Return the text of all tokens in this stream between
+		/// <code>start</code>
+		/// and
+		/// <code>stop</code>
+		/// (inclusive).
+		/// <p/>
+		/// If the specified
+		/// <code>start</code>
+		/// or
+		/// <code>stop</code>
+		/// token was not provided by
+		/// this stream, or if the
+		/// <code>stop</code>
+		/// occurred before the
+		/// <code>start</code>
+		/// token, the behavior is unspecified.
+		/// <p/>
+		/// For streams which ensure that the
+		/// <see cref="Token.GetTokenIndex()">Token.GetTokenIndex()</see>
+		/// 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.
+		/// <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
+		/// <code>start</code>
+		/// and
+		/// <code>stop</code>
+		/// tokens.
+		/// </returns>
+		/// <exception cref="System.NotSupportedException">
+		/// if this stream does not support
+		/// this method for the specified tokens
+		/// </exception>
+		[NotNull]
+		string GetText(Token start, Token stop);
+	}
+}
diff --git a/Antlr4.Runtime/TokenStreamRewriter.cs b/Antlr4.Runtime/TokenStreamRewriter.cs
new file mode 100644
index 000000000..45140ee2b
--- /dev/null
+++ b/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -0,0 +1,745 @@
+/*
+ * [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 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.
+	/// 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. :)
+	/// 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.
+	/// 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.
+	/// 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.
+	/// 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,
+	/// 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();
+	/// 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());
+	/// 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:
+	/// 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"));
+	/// If you don't use named rewrite streams, a "default" stream is used as
+	/// the first example shows.
+	/// </remarks>
+	public class TokenStreamRewriter
+	{
+		public static readonly string DefaultProgramName = "default";
+
+		public const int ProgramInitSize = 100;
+
+		public const int MinTokenIndex = 0;
+
+		public class RewriteOperation
+		{
+			protected internal readonly TokenStream 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(TokenStream tokens, int index)
+			{
+				// Define the rewrite operation hierarchy
+				this.tokens = tokens;
+				this.index = index;
+			}
+
+			protected internal RewriteOperation(TokenStream 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(index) + ":\"" + text + "\">";
+			}
+		}
+
+		internal class InsertBeforeOp : TokenStreamRewriter.RewriteOperation
+		{
+			protected internal InsertBeforeOp(TokenStream tokens, int index, object text) : base
+				(tokens, index, text)
+			{
+			}
+
+			public override int Execute(StringBuilder buf)
+			{
+				buf.Append(text);
+				if (tokens.Get(index).GetType() != Token.Eof)
+				{
+					buf.Append(tokens.Get(index).GetText());
+				}
+				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(TokenStream 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 TokenStream 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) -&gt; rewrite (List)
+		/// </remarks>
+		protected internal readonly IDictionary<string, IList<TokenStreamRewriter.RewriteOperation
+			>> programs;
+
+		/// <summary>Map String (program name) -&gt; Integer index</summary>
+		protected internal readonly IDictionary<string, int> lastRewriteTokenIndexes;
+
+		public TokenStreamRewriter(TokenStream tokens)
+		{
+			this.tokens = tokens;
+			programs = new Dictionary<string, IList<TokenStreamRewriter.RewriteOperation>>();
+			programs.Put(DefaultProgramName, new AList<TokenStreamRewriter.RewriteOperation>(
+				ProgramInitSize));
+			lastRewriteTokenIndexes = new Dictionary<string, int>();
+		}
+
+		public TokenStream GetTokenStream()
+		{
+			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 = programs.Get(programName);
+			if (@is != null)
+			{
+				programs.Put(programName, @is.SubList(MinTokenIndex, instructionIndex));
+			}
+		}
+
+		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(Token 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, Token t, object text)
+		{
+			InsertAfter(programName, t.GetTokenIndex(), 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(Token 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, Token t, object text)
+		{
+			InsertBefore(programName, t.GetTokenIndex(), 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.AddItem(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(Token indexT, object text)
+		{
+			Replace(DefaultProgramName, indexT, indexT, text);
+		}
+
+		public virtual void Replace(Token from, Token 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.AddItem(op);
+		}
+
+		public virtual void Replace(string programName, Token from, Token to, object text
+			)
+		{
+			Replace(programName, from.GetTokenIndex(), to.GetTokenIndex(), 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(Token indexT)
+		{
+			Delete(DefaultProgramName, indexT, indexT);
+		}
+
+		public virtual void Delete(Token from, Token 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, Token from, Token to)
+		{
+			Replace(programName, from, to, null);
+		}
+
+		public virtual int GetLastRewriteTokenIndex()
+		{
+			return GetLastRewriteTokenIndex(DefaultProgramName);
+		}
+
+		protected internal virtual int GetLastRewriteTokenIndex(string programName)
+		{
+			int I = lastRewriteTokenIndexes.Get(programName);
+			if (I == null)
+			{
+				return -1;
+			}
+			return I;
+		}
+
+		protected internal virtual void SetLastRewriteTokenIndex(string programName, int 
+			i)
+		{
+			lastRewriteTokenIndexes.Put(programName, i);
+		}
+
+		protected internal virtual IList<TokenStreamRewriter.RewriteOperation> GetProgram
+			(string name)
+		{
+			IList<TokenStreamRewriter.RewriteOperation> @is = programs.Get(name);
+			if (@is == null)
+			{
+				@is = InitializeProgram(name);
+			}
+			return @is;
+		}
+
+		private IList<TokenStreamRewriter.RewriteOperation> InitializeProgram(string name
+			)
+		{
+			IList<TokenStreamRewriter.RewriteOperation> @is = new AList<TokenStreamRewriter.RewriteOperation
+				>(ProgramInitSize);
+			programs.Put(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 = programs.Get(programName);
+			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.IsEmpty())
+			{
+				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 = indexToOp.Get(i);
+				Sharpen.Collections.Remove(indexToOp, i);
+				// remove so any left have index size-1
+				Token t = tokens.Get(i);
+				if (op == null)
+				{
+					// no operation at that index, just dump token
+					if (t.GetType() != Token.Eof)
+					{
+						buf.Append(t.GetText());
+					}
+					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 -&gt; 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.Set(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.Set(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.Set(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.Set(prevRop.instructionIndex, null);
+						// kill first delete
+						rop.index = Math.Min(prevRop.index, rop.index);
+						rop.lastIndex = Math.Max(prevRop.lastIndex, rop.lastIndex);
+						System.Console.Out.WriteLine("new rop " + rop);
+					}
+					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.Set(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.Set(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.Get(op.index) != null)
+				{
+					throw new Error("should only be one op per index");
+				}
+				m.Put(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, _T1>(IList<_T1> rewrites, int
+			 before) where T:TokenStreamRewriter.RewriteOperation where _T1:TokenStreamRewriter.RewriteOperation
+		{
+			System.Type kind = typeof(T);
+			IList<T> ops = new AList<T>();
+			for (int i = 0; i < before && i < rewrites.Count; i++)
+			{
+				TokenStreamRewriter.RewriteOperation op = rewrites[i];
+				if (op == null)
+				{
+					continue;
+				}
+				// ignore deleted
+				if (kind.IsInstanceOfType(op))
+				{
+					ops.AddItem(kind.Cast(op));
+				}
+			}
+			return ops;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
new file mode 100644
index 000000000..c2f9e078c
--- /dev/null
+++ b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
@@ -0,0 +1,231 @@
+/*
+ * [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.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public abstract class AbstractParseTreeVisitor<Result> : ParseTreeVisitor<Result>
+	{
+		/// <summary>
+		/// <inheritDoc></inheritDoc>
+		/// <p/>
+		/// The default implementation calls
+		/// <see cref="ParseTree.Accept{T}(ParseTreeVisitor{Result})">ParseTree.Accept&lt;T&gt;(ParseTreeVisitor&lt;Result&gt;)
+		/// 	</see>
+		/// on the
+		/// specified tree.
+		/// </summary>
+		public virtual Result Visit(ParseTree tree)
+		{
+			return tree.Accept(this);
+		}
+
+		/// <summary>
+		/// <inheritDoc></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(RuleNode, object)
+		/// 	">shouldVisitNextChild</see>
+		/// ; if the result
+		/// is
+		/// <code>false</code>
+		/// 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(object, object)">aggregateResult
+		/// 	</see>
+		/// with the
+		/// previous aggregate result and the result of visiting the child.
+		/// </summary>
+		public virtual Result VisitChildren(RuleNode node)
+		{
+			Result result = DefaultResult();
+			int n = node.GetChildCount();
+			for (int i = 0; i < n; i++)
+			{
+				if (!ShouldVisitNextChild(node, result))
+				{
+					break;
+				}
+				ParseTree c = node.GetChild(i);
+				Result childResult = c.Accept(this);
+				result = AggregateResult(result, childResult);
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// <inheritDoc></inheritDoc>
+		/// <p/>
+		/// The default implementation returns the result of
+		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
+		/// .
+		/// </summary>
+		public virtual Result VisitTerminal(TerminalNode node)
+		{
+			return DefaultResult();
+		}
+
+		/// <summary>
+		/// <inheritDoc></inheritDoc>
+		/// <p/>
+		/// The default implementation returns the result of
+		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
+		/// .
+		/// </summary>
+		public virtual Result VisitErrorNode(ErrorNode 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(TerminalNode)">visitTerminal
+		/// 	</see>
+		/// ,
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitErrorNode(ErrorNode)">visitErrorNode
+		/// 	</see>
+		/// .
+		/// The default implementation of
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">visitChildren
+		/// 	</see>
+		/// initializes its aggregate result to this value.
+		/// <p/>
+		/// The base implementation returns
+		/// <code>null</code>
+		/// .
+		/// </remarks>
+		/// <returns>The default value returned by visitor methods.</returns>
+		protected internal virtual Result DefaultResult()
+		{
+			return null;
+		}
+
+		/// <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(RuleNode, object)
+		/// 	">AbstractParseTreeVisitor&lt;Result&gt;.ShouldVisitNextChild(RuleNode, object)</see>
+		/// returns
+		/// <code>false</code>
+		/// , the aggregate value is returned as the result of
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// 	</see>
+		/// .
+		/// <p/>
+		/// The default implementation returns
+		/// <code>nextResult</code>
+		/// , meaning
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// 	</see>
+		/// will return the result of the last child visited
+		/// (or return the initial value if the node has no children).
+		/// </remarks>
+		/// <param name="aggregate">
+		/// The previous aggregate value. In the default
+		/// implementation, the aggregate value is initialized to
+		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">AbstractParseTreeVisitor&lt;Result&gt;.DefaultResult()
+		/// 	</see>
+		/// , which is passed as the
+		/// <code>aggregate</code>
+		/// 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(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// 	</see>
+		/// . This method is first called before the first
+		/// child is visited; at that point
+		/// <code>currentResult</code>
+		/// will be the initial
+		/// value (in the default implementation, the initial value is returned by a
+		/// call to
+		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">AbstractParseTreeVisitor&lt;Result&gt;.DefaultResult()
+		/// 	</see>
+		/// . This method is not called after the last
+		/// child is visited.
+		/// <p/>
+		/// The default implementation always returns
+		/// <code>true</code>
+		/// , indicating that
+		/// <code>visitChildren</code>
+		/// 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.
+		/// </summary>
+		/// <param name="node">
+		/// The
+		/// <see cref="RuleNode">RuleNode</see>
+		/// whose children are currently being
+		/// visited.
+		/// </param>
+		/// <param name="currentResult">
+		/// The current aggregate result of the children visited
+		/// to the current point.
+		/// </param>
+		/// <returns>
+		/// 
+		/// <code>true</code>
+		/// to continue visiting children. Otherwise return
+		/// <code>false</code>
+		/// to stop visiting children and immediately return the
+		/// current aggregate result from
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// 	</see>
+		/// .
+		/// </returns>
+		protected internal virtual bool ShouldVisitNextChild(RuleNode node, Result currentResult
+			)
+		{
+			return true;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Tree/ErrorNode.cs b/Antlr4.Runtime/Tree/ErrorNode.cs
new file mode 100644
index 000000000..a6ad6be06
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ErrorNode.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.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public interface ErrorNode : TerminalNode
+	{
+	}
+}
diff --git a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
new file mode 100644
index 000000000..28e805138
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
@@ -0,0 +1,58 @@
+/*
+ * [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.Tree;
+using Sharpen;
+
+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, ErrorNode
+	{
+		public ErrorNodeImpl(Token token) : base(token)
+		{
+		}
+
+		public override T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor)
+		{
+			return visitor.VisitErrorNode(this);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Tree/ParseTree.cs b/Antlr4.Runtime/Tree/ParseTree.cs
new file mode 100644
index 000000000..4b9bb07a7
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ParseTree.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.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	/// <summary>
+	/// An interface to access the tree of
+	/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+	/// 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.Token">Antlr4.Runtime.Token</see>
+	/// or a
+	/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+	/// object.
+	/// </summary>
+	public interface ParseTree : SyntaxTree
+	{
+		// the following methods narrow the return type; they are not additional methods
+		ParseTree GetParent();
+
+		ParseTree GetChild(int i);
+
+		/// <summary>
+		/// The
+		/// <see cref="ParseTreeVisitor{Result}">ParseTreeVisitor&lt;Result&gt;</see>
+		/// needs a double dispatch method.
+		/// </summary>
+		T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor) where _T1:T;
+
+		/// <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/Antlr4.Runtime/Tree/ParseTreeListener.cs b/Antlr4.Runtime/Tree/ParseTreeListener.cs
new file mode 100644
index 000000000..a72b34b27
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ParseTreeListener.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.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public interface ParseTreeListener
+	{
+		void VisitTerminal(TerminalNode node);
+
+		void VisitErrorNode(ErrorNode node);
+
+		void EnterEveryRule(ParserRuleContext ctx);
+
+		void ExitEveryRule(ParserRuleContext ctx);
+	}
+}
diff --git a/Antlr4.Runtime/Tree/ParseTreeProperty.cs b/Antlr4.Runtime/Tree/ParseTreeProperty.cs
new file mode 100644
index 000000000..02058e231
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ParseTreeProperty.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.Tree;
+using Sharpen;
+
+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 IDictionary<ParseTree, V> annotations = new IdentityHashMap<ParseTree
+			, V>();
+
+		public virtual V Get(ParseTree node)
+		{
+			return annotations.Get(node);
+		}
+
+		public virtual void Put(ParseTree node, V value)
+		{
+			annotations.Put(node, value);
+		}
+
+		public virtual V RemoveFrom(ParseTree node)
+		{
+			return Sharpen.Collections.Remove(annotations, node);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Tree/ParseTreeVisitor.cs b/Antlr4.Runtime/Tree/ParseTreeVisitor.cs
new file mode 100644
index 000000000..a968a9aef
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ParseTreeVisitor.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.Tree;
+using Sharpen;
+
+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
+	/// <code>XVisitor</code>
+	/// interface for
+	/// grammar
+	/// <code>X</code>
+	/// .
+	/// </remarks>
+	/// <author>Sam Harwell</author>
+	/// <?></?>
+	public interface ParseTreeVisitor<Result>
+	{
+		/// <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="ParseTree">ParseTree</see>
+		/// to visit.
+		/// </param>
+		/// <returns>The result of visiting the parse tree.</returns>
+		Result Visit(ParseTree 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="RuleNode">RuleNode</see>
+		/// whose children should be visited.
+		/// </param>
+		/// <returns>The result of visiting the children of the node.</returns>
+		Result VisitChildren(RuleNode 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="TerminalNode">TerminalNode</see>
+		/// to visit.
+		/// </param>
+		/// <returns>The result of visiting the node.</returns>
+		Result VisitTerminal(TerminalNode 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="ErrorNode">ErrorNode</see>
+		/// to visit.
+		/// </param>
+		/// <returns>The result of visiting the node.</returns>
+		Result VisitErrorNode(ErrorNode node);
+	}
+}
diff --git a/Antlr4.Runtime/Tree/ParseTreeWalker.cs b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
new file mode 100644
index 000000000..e288c2e49
--- /dev/null
+++ b/Antlr4.Runtime/Tree/ParseTreeWalker.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 Antlr4.Runtime;
+using Antlr4.Runtime.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public class ParseTreeWalker
+	{
+		public static readonly ParseTreeWalker Default = new ParseTreeWalker();
+
+		public virtual void Walk(ParseTreeListener listener, ParseTree t)
+		{
+			if (t is ErrorNode)
+			{
+				listener.VisitErrorNode((ErrorNode)t);
+				return;
+			}
+			else
+			{
+				if (t is TerminalNode)
+				{
+					listener.VisitTerminal((TerminalNode)t);
+					return;
+				}
+			}
+			RuleNode r = (RuleNode)t;
+			EnterRule(listener, r);
+			int n = r.GetChildCount();
+			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="ParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)">ParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)
+		/// 	</see>
+		/// and a
+		/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+		/// -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(ParseTreeListener listener, RuleNode r)
+		{
+			ParserRuleContext ctx = (ParserRuleContext)r.GetRuleContext();
+			listener.EnterEveryRule(ctx);
+			ctx.EnterRule(listener);
+		}
+
+		protected internal virtual void ExitRule(ParseTreeListener listener, RuleNode r)
+		{
+			ParserRuleContext ctx = (ParserRuleContext)r.GetRuleContext();
+			ctx.ExitRule(listener);
+			listener.ExitEveryRule(ctx);
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Tree/RuleNode.cs b/Antlr4.Runtime/Tree/RuleNode.cs
new file mode 100644
index 000000000..a741ca014
--- /dev/null
+++ b/Antlr4.Runtime/Tree/RuleNode.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.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public interface RuleNode : ParseTree
+	{
+		RuleContext GetRuleContext();
+
+		RuleNode GetParent();
+	}
+}
diff --git a/Antlr4.Runtime/Tree/SyntaxTree.cs b/Antlr4.Runtime/Tree/SyntaxTree.cs
new file mode 100644
index 000000000..0a40dae8c
--- /dev/null
+++ b/Antlr4.Runtime/Tree/SyntaxTree.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.Tree;
+using Sharpen;
+
+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 SyntaxTree : Antlr4.Runtime.Tree.Tree
+	{
+		/// <summary>
+		/// Return an
+		/// <see cref="Antlr4.Runtime.Misc.Interval">Antlr4.Runtime.Misc.Interval</see>
+		/// indicating the index in the
+		/// <see cref="Antlr4.Runtime.TokenStream">Antlr4.Runtime.TokenStream</see>
+		/// 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">Antlr4.Runtime.Misc.Interval.Invalid
+		/// 	</see>
+		/// .
+		/// </summary>
+		[NotNull]
+		Interval GetSourceInterval();
+	}
+}
diff --git a/Antlr4.Runtime/Tree/TerminalNode.cs b/Antlr4.Runtime/Tree/TerminalNode.cs
new file mode 100644
index 000000000..b1c9c08be
--- /dev/null
+++ b/Antlr4.Runtime/Tree/TerminalNode.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.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public interface TerminalNode : ParseTree
+	{
+		Token GetSymbol();
+
+		RuleNode GetParent();
+	}
+}
diff --git a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
new file mode 100644
index 000000000..3d7ca4636
--- /dev/null
+++ b/Antlr4.Runtime/Tree/TerminalNodeImpl.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.Misc;
+using Antlr4.Runtime.Tree;
+using Sharpen;
+
+namespace Antlr4.Runtime.Tree
+{
+	public class TerminalNodeImpl : TerminalNode
+	{
+		public Token symbol;
+
+		public RuleNode parent;
+
+		public TerminalNodeImpl(Token symbol)
+		{
+			this.symbol = symbol;
+		}
+
+		public virtual ParseTree GetChild(int i)
+		{
+			return null;
+		}
+
+		public virtual Token GetSymbol()
+		{
+			return symbol;
+		}
+
+		public virtual RuleNode GetParent()
+		{
+			return parent;
+		}
+
+		public virtual Token GetPayload()
+		{
+			return symbol;
+		}
+
+		public virtual Interval GetSourceInterval()
+		{
+			if (symbol != null)
+			{
+				int tokenIndex = symbol.GetTokenIndex();
+				return new Interval(tokenIndex, tokenIndex);
+			}
+			return Interval.Invalid;
+		}
+
+		public virtual int GetChildCount()
+		{
+			return 0;
+		}
+
+		public virtual T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor) where _T1:T
+		{
+			return visitor.VisitTerminal(this);
+		}
+
+		public virtual string GetText()
+		{
+			if (symbol != null)
+			{
+				return symbol.GetText();
+			}
+			return null;
+		}
+
+		public virtual string ToStringTree(Parser parser)
+		{
+			return ToString();
+		}
+
+		public override string ToString()
+		{
+			if (symbol != null)
+			{
+				if (symbol.GetType() == Token.Eof)
+				{
+					return "<EOF>";
+				}
+				return symbol.GetText();
+			}
+			else
+			{
+				return symbol != null ? symbol.ToString() : "<null>";
+			}
+		}
+
+		public virtual string ToStringTree()
+		{
+			return ToString();
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Tree/Tree.cs b/Antlr4.Runtime/Tree/Tree.cs
new file mode 100644
index 000000000..9256db8c6
--- /dev/null
+++ b/Antlr4.Runtime/Tree/Tree.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 Sharpen;
+
+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 Tree
+	{
+		/// <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>
+		Antlr4.Runtime.Tree.Tree GetParent();
+
+		/// <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.Token">Antlr4.Runtime.Token</see>
+		/// representing
+		/// a leaf node or a
+		/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+		/// object representing a rule
+		/// invocation. For abstract syntax trees (ASTs), this is a
+		/// <see cref="Antlr4.Runtime.Token">Antlr4.Runtime.Token</see>
+		/// object.
+		/// </remarks>
+		object GetPayload();
+
+		/// <summary>
+		/// If there are children, get the
+		/// <code>i</code>
+		/// th value indexed from 0.
+		/// </summary>
+		Antlr4.Runtime.Tree.Tree 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 GetChildCount();
+
+		/// <summary>
+		/// Print out a whole tree, not just a node, in LISP format
+		/// <code>(root child1 .. childN)</code>
+		/// . Print just a node if this is a leaf.
+		/// </summary>
+		string ToStringTree();
+	}
+}
diff --git a/Antlr4.Runtime/Tree/Trees.cs b/Antlr4.Runtime/Tree/Trees.cs
new file mode 100644
index 000000000..502bd5ec6
--- /dev/null
+++ b/Antlr4.Runtime/Tree/Trees.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 System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
+using Antlr4.Runtime.Tree.Gui;
+using Sharpen;
+
+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
+	{
+		public static string GetPS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames, string
+			 fontName, int fontSize)
+		{
+			TreePostScriptGenerator psgen = new TreePostScriptGenerator(ruleNames, t, fontName
+				, fontSize);
+			return psgen.GetPS();
+		}
+
+		public static string GetPS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames)
+		{
+			return GetPS(t, ruleNames, "Helvetica", 11);
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public static void WritePS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames, string
+			 fileName, string fontName, int fontSize)
+		{
+			string ps = GetPS(t, ruleNames, fontName, fontSize);
+			FileWriter f = new FileWriter(fileName);
+			BufferedWriter bw = new BufferedWriter(f);
+			bw.Write(ps);
+			bw.Close();
+		}
+
+		/// <exception cref="System.IO.IOException"></exception>
+		public static void WritePS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames, string
+			 fileName)
+		{
+			WritePS(t, ruleNames, fileName, "Helvetica", 11);
+		}
+
+		/// <summary>Print out a whole tree in LISP form.</summary>
+		/// <remarks>
+		/// Print out a whole tree in LISP form.
+		/// <see cref="GetNodeText(Tree, Antlr4.Runtime.Parser)">GetNodeText(Tree, Antlr4.Runtime.Parser)
+		/// 	</see>
+		/// 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(Antlr4.Runtime.Tree.Tree 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(Tree, Antlr4.Runtime.Parser)">GetNodeText(Tree, Antlr4.Runtime.Parser)
+		/// 	</see>
+		/// 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(Antlr4.Runtime.Tree.Tree t, Parser recog)
+		{
+			string[] ruleNames = recog != null ? recog.GetRuleNames() : 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(Tree, Antlr4.Runtime.Parser)">GetNodeText(Tree, Antlr4.Runtime.Parser)
+		/// 	</see>
+		/// 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(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames
+			)
+		{
+			string s = Utils.EscapeWhitespace(GetNodeText(t, ruleNames), false);
+			if (t.GetChildCount() == 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.GetChildCount(); i++)
+			{
+				if (i > 0)
+				{
+					buf.Append(' ');
+				}
+				buf.Append(ToStringTree(t.GetChild(i), ruleNames));
+			}
+			buf.Append(")");
+			return buf.ToString();
+		}
+
+		public static string GetNodeText(Antlr4.Runtime.Tree.Tree t, Parser recog)
+		{
+			string[] ruleNames = recog != null ? recog.GetRuleNames() : null;
+			IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
+			return GetNodeText(t, ruleNamesList);
+		}
+
+		public static string GetNodeText(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames
+			)
+		{
+			if (ruleNames != null)
+			{
+				if (t is RuleNode)
+				{
+					int ruleIndex = ((RuleNode)t).GetRuleContext().GetRuleIndex();
+					string ruleName = ruleNames[ruleIndex];
+					return ruleName;
+				}
+				else
+				{
+					if (t is ErrorNode)
+					{
+						return t.ToString();
+					}
+					else
+					{
+						if (t is TerminalNode)
+						{
+							object symbol = ((TerminalNode)t).GetSymbol();
+							if (symbol is Token)
+							{
+								string s = ((Token)symbol).GetText();
+								return s;
+							}
+						}
+					}
+				}
+			}
+			// no recog for rule names
+			object payload = t.GetPayload();
+			if (payload is Token)
+			{
+				return ((Token)payload).GetText();
+			}
+			return t.GetPayload().ToString();
+		}
+
+		/// <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>
+		[NotNull]
+		public static IList<Antlr4.Runtime.Tree.Tree> GetAncestors(Antlr4.Runtime.Tree.Tree
+			 t)
+		{
+			if (t.GetParent() == null)
+			{
+				return Sharpen.Collections.EmptyList();
+			}
+			IList<Antlr4.Runtime.Tree.Tree> ancestors = new AList<Antlr4.Runtime.Tree.Tree>();
+			t = t.GetParent();
+			while (t != null)
+			{
+				ancestors.Add(0, t);
+				// insert at start
+				t = t.GetParent();
+			}
+			return ancestors;
+		}
+
+		public Trees()
+		{
+		}
+	}
+}
diff --git a/Antlr4.Runtime/UnbufferedCharStream.cs b/Antlr4.Runtime/UnbufferedCharStream.cs
new file mode 100644
index 000000000..b390d0965
--- /dev/null
+++ b/Antlr4.Runtime/UnbufferedCharStream.cs
@@ -0,0 +1,438 @@
+/*
+ * [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 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 : CharStream
+	{
+		/// <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
+		/// <code>data.length</code>
+		/// .
+		/// </summary>
+		protected internal int n;
+
+		/// <summary>
+		/// 0..n-1 index into
+		/// <see cref="data">data</see>
+		/// of next character.
+		/// <p/>
+		/// The
+		/// <code>LA(1)</code>
+		/// character is
+		/// <code>data[p]</code>
+		/// . If
+		/// <code>p == n</code>
+		/// , we are
+		/// out of buffered characters.
+		/// </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
+		/// <code>release()</code>
+		/// the last mark,
+		/// <code>numMarkers</code>
+		/// reaches 0 and we reset the buffer. Copy
+		/// <code>data[p]..data[n-1]</code>
+		/// to
+		/// <code>data[0]..data[(n-1)-p]</code>
+		/// .
+		/// </summary>
+		protected internal int numMarkers = 0;
+
+		/// <summary>
+		/// This is the
+		/// <code>LA(-1)</code>
+		/// character for the current position.
+		/// </summary>
+		protected internal int lastChar = -1;
+
+		/// <summary>
+		/// When
+		/// <code>numMarkers &gt; 0</code>
+		/// , this is the
+		/// <code>LA(-1)</code>
+		/// 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
+		/// <code>LA(1)</code>
+		/// . 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 StreamReader 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(InputStream input) : this(input, 256)
+		{
+		}
+
+		public UnbufferedCharStream(StreamReader input) : this(input, 256)
+		{
+		}
+
+		public UnbufferedCharStream(InputStream input, int bufferSize) : this(bufferSize)
+		{
+			this.input = new InputStreamReader(input);
+			Fill(1);
+		}
+
+		public UnbufferedCharStream(StreamReader input, int bufferSize) : this(bufferSize
+			)
+		{
+			// prime
+			this.input = input;
+			Fill(1);
+		}
+
+		// prime
+		public virtual void Consume()
+		{
+			if (La(1) == IntStream.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
+		/// <code>p</code>
+		/// index is
+		/// <code>data.length-1</code>
+		/// .
+		/// <code>p+need-1</code>
+		/// is
+		/// the char index 'need' elements ahead. If we need 1 element,
+		/// <code>(p+1-1)==p</code>
+		/// must be less than
+		/// <code>data.length</code>
+		/// .
+		/// </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
+		/// <code>n</code>
+		/// characters to the buffer. Returns the number of characters
+		/// actually added to the buffer. If the return value is less than
+		/// <code>n</code>
+		/// ,
+		/// then EOF was reached before
+		/// <code>n</code>
+		/// 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] == IntStream.Eof)
+				{
+					return i;
+				}
+				try
+				{
+					int c = NextChar();
+					Add(c);
+				}
+				catch (IOException ioe)
+				{
+					throw new RuntimeException(ioe);
+				}
+			}
+			return n;
+		}
+
+		/// <summary>
+		/// Override to provide different source of characters than
+		/// <see cref="input">input</see>
+		/// .
+		/// </summary>
+		/// <exception cref="System.IO.IOException"></exception>
+		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 IndexOutOfRangeException();
+			}
+			if (index > n)
+			{
+				return IntStream.Eof;
+			}
+			int c = data[index];
+			if (c == (char)IntStream.Eof)
+			{
+				return IntStream.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
+		/// <code>seek()</code>
+		/// is called on a mark or
+		/// <code>release()</code>
+		/// is called in the wrong order.
+		/// </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"></param>
+		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()
+		{
+			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
+		/// <code>p</code>
+		/// to
+		/// <code>index-bufferStartIndex</code>
+		/// .
+		/// </remarks>
+		public virtual void Seek(int index)
+		{
+			if (index == currentCharIndex)
+			{
+				return;
+			}
+			if (index > currentCharIndex)
+			{
+				Sync(index - currentCharIndex);
+				index = Math.Min(index, GetBufferStartIndex() + n - 1);
+			}
+			// index == to bufferStartIndex should set p to 0
+			int i = index - GetBufferStartIndex();
+			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 "
+						 + GetBufferStartIndex() + ".." + (GetBufferStartIndex() + n));
+				}
+			}
+			p = i;
+			currentCharIndex = index;
+			if (p == 0)
+			{
+				lastChar = lastCharBufferStart;
+			}
+			else
+			{
+				lastChar = data[p - 1];
+			}
+		}
+
+		public virtual int Size()
+		{
+			throw new NotSupportedException("Unbuffered stream cannot know its size");
+		}
+
+		public virtual string GetSourceName()
+		{
+			return name;
+		}
+
+		public override string GetText(Interval interval)
+		{
+			if (interval.a < 0 || interval.b < interval.a - 1)
+			{
+				throw new ArgumentException("invalid interval");
+			}
+			int bufferStartIndex = GetBufferStartIndex();
+			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));
+			}
+			// convert from absolute to local index
+			int i = interval.a - bufferStartIndex;
+			return new string(data, i, interval.Length());
+		}
+
+		protected internal int GetBufferStartIndex()
+		{
+			return currentCharIndex - p;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/UnbufferedTokenStream.cs b/Antlr4.Runtime/UnbufferedTokenStream.cs
new file mode 100644
index 000000000..a78c21262
--- /dev/null
+++ b/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -0,0 +1,422 @@
+/*
+ * [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 Sharpen;
+
+namespace Antlr4.Runtime
+{
+	public class UnbufferedTokenStream : TokenStream
+	{
+		protected internal TokenSource 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 Token[] tokens;
+
+		/// <summary>
+		/// The number of tokens currently in
+		/// <see cref="tokens">tokens</see>
+		/// .
+		/// <p/>
+		/// This is not the buffer capacity, that's
+		/// <code>tokens.length</code>
+		/// .
+		/// </summary>
+		protected internal int n;
+
+		/// <summary>
+		/// 0..n-1 index into
+		/// <see cref="tokens">tokens</see>
+		/// of next token.
+		/// <p/>
+		/// The
+		/// <code>LT(1)</code>
+		/// token is
+		/// <code>tokens[p]</code>
+		/// . If
+		/// <code>p == n</code>
+		/// , we are
+		/// out of buffered tokens.
+		/// </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
+		/// <code>release()</code>
+		/// the last mark,
+		/// <code>numMarkers</code>
+		/// reaches 0 and we reset the buffer. Copy
+		/// <code>tokens[p]..tokens[n-1]</code>
+		/// to
+		/// <code>tokens[0]..tokens[(n-1)-p]</code>
+		/// .
+		/// </summary>
+		protected internal int numMarkers = 0;
+
+		/// <summary>
+		/// This is the
+		/// <code>LT(-1)</code>
+		/// token for the current position.
+		/// </summary>
+		protected internal Token lastToken;
+
+		/// <summary>
+		/// When
+		/// <code>numMarkers &gt; 0</code>
+		/// , this is the
+		/// <code>LT(-1)</code>
+		/// token for the
+		/// first token in
+		/// <see cref="tokens">tokens</see>
+		/// . Otherwise, this is
+		/// <code>null</code>
+		/// .
+		/// </summary>
+		protected internal Token lastTokenBufferStart;
+
+		/// <summary>Absolute token index.</summary>
+		/// <remarks>
+		/// Absolute token index. It's the index of the token about to be read via
+		/// <code>LT(1)</code>
+		/// . 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="WritableToken">WritableToken</see>
+		/// .
+		/// </remarks>
+		protected internal int currentTokenIndex = 0;
+
+		public UnbufferedTokenStream(TokenSource tokenSource) : this(tokenSource, 256)
+		{
+		}
+
+		public UnbufferedTokenStream(TokenSource tokenSource, int bufferSize)
+		{
+			this.tokenSource = tokenSource;
+			Token[] tokens = new Token[bufferSize];
+			this.tokens = tokens;
+			n = 0;
+			Fill(1);
+		}
+
+		// prime the pump
+		public virtual Token Get(int i)
+		{
+			int bufferStartIndex = GetBufferStartIndex();
+			if (i < bufferStartIndex || i >= bufferStartIndex + n)
+			{
+				throw new IndexOutOfRangeException("get(" + i + ") outside buffer: " + bufferStartIndex
+					 + ".." + (bufferStartIndex + n));
+			}
+			return tokens[i - bufferStartIndex];
+		}
+
+		public virtual Token Lt(int i)
+		{
+			if (i == -1)
+			{
+				return lastToken;
+			}
+			Sync(i);
+			int index = p + i - 1;
+			if (index < 0)
+			{
+				throw new IndexOutOfRangeException("LT(" + i + ") gives negative index");
+			}
+			if (index >= n)
+			{
+				System.Diagnostics.Debug.Assert(n > 0 && tokens[n - 1].GetType() == Token.Eof);
+				return tokens[n - 1];
+			}
+			return tokens[index];
+		}
+
+		public virtual int La(int i)
+		{
+			return Lt(i).GetType();
+		}
+
+		public virtual TokenSource GetTokenSource()
+		{
+			return tokenSource;
+		}
+
+		[NotNull]
+		public virtual string GetText()
+		{
+			return string.Empty;
+		}
+
+		[NotNull]
+		public virtual string GetText(RuleContext ctx)
+		{
+			return GetText(ctx.GetSourceInterval());
+		}
+
+		[NotNull]
+		public virtual string GetText(Token start, Token stop)
+		{
+			if (start != null && stop != null)
+			{
+				return GetText(Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex()));
+			}
+			throw new NotSupportedException("The specified start and stop symbols are not supported."
+				);
+		}
+
+		public virtual void Consume()
+		{
+			if (La(1) == Token.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
+		/// <code>p</code>
+		/// index is
+		/// <code>tokens.length-1</code>
+		/// .
+		/// <code>p+need-1</code>
+		/// is the tokens index 'need' elements
+		/// ahead.  If we need 1 element,
+		/// <code>(p+1-1)==p</code>
+		/// must be less than
+		/// <code>tokens.length</code>
+		/// .
+		/// </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
+		/// <code>n</code>
+		/// elements to the buffer. Returns the number of tokens
+		/// actually added to the buffer. If the return value is less than
+		/// <code>n</code>
+		/// ,
+		/// then EOF was reached before
+		/// <code>n</code>
+		/// 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].GetType() == Token.Eof)
+				{
+					return i;
+				}
+				Token t = tokenSource.NextToken();
+				Add(t);
+			}
+			return n;
+		}
+
+		protected internal virtual void Add(Token t)
+		{
+			if (n >= tokens.Length)
+			{
+				tokens = Arrays.CopyOf(tokens, tokens.Length * 2);
+			}
+			if (t is WritableToken)
+			{
+				((WritableToken)t).SetTokenIndex(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
+		/// <code>seek()</code>
+		/// is called on a mark or
+		/// <code>release()</code>
+		/// is called in the wrong order.
+		/// </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()
+		{
+			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()
+		{
+			throw new NotSupportedException("Unbuffered stream cannot know its size");
+		}
+
+		public virtual string GetSourceName()
+		{
+			return tokenSource.GetSourceName();
+		}
+
+		[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++)
+			{
+				Token t = tokens[i];
+				buf.Append(t.GetText());
+			}
+			return buf.ToString();
+		}
+
+		protected internal int GetBufferStartIndex()
+		{
+			return currentTokenIndex - p;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/WritableToken.cs b/Antlr4.Runtime/WritableToken.cs
new file mode 100644
index 000000000..9d2acfc5b
--- /dev/null
+++ b/Antlr4.Runtime/WritableToken.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;
+using Sharpen;
+
+namespace Antlr4.Runtime
+{
+	public interface WritableToken : Token
+	{
+		void SetText(string text);
+
+		void SetType(int ttype);
+
+		void SetLine(int line);
+
+		void SetCharPositionInLine(int pos);
+
+		void SetChannel(int channel);
+
+		void SetTokenIndex(int index);
+	}
+}

From 457d6e0aa4fa8ebaf1e70e6d149485b3134aaa9b Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Fri, 15 Feb 2013 15:32:56 -0600
Subject: [PATCH 02/10] Updated ANTLR 4 reference revision

---
 Antlr4.Runtime/TokenStreamRewriter.cs | 6 +++---
 reference/antlr4                      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Antlr4.Runtime/TokenStreamRewriter.cs b/Antlr4.Runtime/TokenStreamRewriter.cs
index 45140ee2b..8e8fc19cd 100644
--- a/Antlr4.Runtime/TokenStreamRewriter.cs
+++ b/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -140,9 +140,9 @@ namespace Antlr4.Runtime
 			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(index) + ":\"" + text + "\">";
+				int index = opName.IndexOf('$');
+				opName = Sharpen.Runtime.Substring(opName, index + 1, opName.Length);
+				return "<" + opName + "@" + tokens.Get(this.index) + ":\"" + text + "\">";
 			}
 		}
 
diff --git a/reference/antlr4 b/reference/antlr4
index 7fe8a6353..ad17f36a4 160000
--- a/reference/antlr4
+++ b/reference/antlr4
@@ -1 +1 @@
-Subproject commit 7fe8a6353fab1798fa29777ed1f576aeae716cbf
+Subproject commit ad17f36a468eb693df02676fa108567bcd319c5a

From fdec53d82dd95e677653c03e2d371ba90c34a261 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Fri, 15 Feb 2013 15:44:38 -0600
Subject: [PATCH 03/10] Updated type mappings for interfaces

---
 Antlr4.Runtime/Atn/ParserATNSimulator.cs      | 35 ++++++------
 Antlr4.Runtime/BaseErrorListener.cs           |  2 +-
 Antlr4.Runtime/BufferedTokenStream.cs         | 14 ++---
 Antlr4.Runtime/CommonToken.cs                 |  8 +--
 Antlr4.Runtime/CommonTokenFactory.cs          |  6 +-
 Antlr4.Runtime/CommonTokenStream.cs           |  4 +-
 Antlr4.Runtime/ConsoleErrorListener.cs        |  2 +-
 Antlr4.Runtime/DefaultErrorStrategy.cs        | 28 ++++-----
 Antlr4.Runtime/Dfa/AbstractEdgeMap.cs         |  6 +-
 Antlr4.Runtime/Dfa/ArrayEdgeMap.cs            |  2 +-
 Antlr4.Runtime/Dfa/DFA.cs                     |  4 +-
 Antlr4.Runtime/Dfa/EdgeMap.cs                 |  9 ++-
 Antlr4.Runtime/DiagnosticErrorListener.cs     | 12 ++--
 Antlr4.Runtime/FailedPredicateException.cs    |  2 +-
 Antlr4.Runtime/InputMismatchException.cs      |  2 +-
 Antlr4.Runtime/Lexer.cs                       | 12 ++--
 Antlr4.Runtime/Misc/IntSet.cs                 | 11 ++--
 Antlr4.Runtime/Misc/IntervalSet.cs            | 12 ++--
 Antlr4.Runtime/Misc/TestRig.cs                |  4 +-
 Antlr4.Runtime/NoViableAltException.cs        |  8 +--
 Antlr4.Runtime/Parser.cs                      | 57 +++++++++----------
 Antlr4.Runtime/ParserErrorListener.cs         |  2 +-
 Antlr4.Runtime/ParserRuleContext.cs           | 44 +++++++-------
 Antlr4.Runtime/ProxyErrorListener.cs          | 11 ++--
 Antlr4.Runtime/ProxyParserErrorListener.cs    | 24 ++++----
 Antlr4.Runtime/Recognizer.cs                  | 14 ++---
 Antlr4.Runtime/RuleContext.cs                 |  6 +-
 Antlr4.Runtime/Token.cs                       |  4 +-
 Antlr4.Runtime/TokenFactory.cs                |  2 +-
 Antlr4.Runtime/TokenSource.cs                 |  4 +-
 Antlr4.Runtime/TokenStream.cs                 |  4 +-
 Antlr4.Runtime/TokenStreamRewriter.cs         | 18 +++---
 .../Tree/AbstractParseTreeVisitor.cs          | 40 ++++++-------
 Antlr4.Runtime/Tree/ErrorNode.cs              |  3 +-
 Antlr4.Runtime/Tree/ErrorNodeImpl.cs          |  4 +-
 Antlr4.Runtime/Tree/ParseTree.cs              |  9 ++-
 Antlr4.Runtime/Tree/ParseTreeListener.cs      |  5 +-
 Antlr4.Runtime/Tree/ParseTreeProperty.cs      |  8 +--
 Antlr4.Runtime/Tree/ParseTreeVisitor.cs       | 17 +++---
 Antlr4.Runtime/Tree/ParseTreeWalker.cs        | 20 ++++---
 Antlr4.Runtime/Tree/RuleNode.cs               |  5 +-
 Antlr4.Runtime/Tree/SyntaxTree.cs             |  5 +-
 Antlr4.Runtime/Tree/TerminalNode.cs           |  5 +-
 Antlr4.Runtime/Tree/TerminalNodeImpl.cs       | 11 ++--
 Antlr4.Runtime/Tree/Tree.cs                   |  4 +-
 Antlr4.Runtime/Tree/Trees.cs                  | 47 +++++++--------
 Antlr4.Runtime/UnbufferedTokenStream.cs       | 16 +++---
 reference/sharpen-all-options.txt             | 20 +++++++
 48 files changed, 300 insertions(+), 292 deletions(-)

diff --git a/Antlr4.Runtime/Atn/ParserATNSimulator.cs b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
index b481901e4..461f85061 100644
--- a/Antlr4.Runtime/Atn/ParserATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
@@ -232,8 +232,7 @@ namespace Antlr4.Runtime.Atn
 		/// <code>true</code>
 		/// , ambiguous alternatives are reported when they are
 		/// encountered within
-		/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.TokenStream, int, SimulatorState)
-		/// 	">ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.TokenStream, int, SimulatorState)
+		/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, ITokenStream, int, SimulatorState)">ExecATN(Antlr4.Runtime.Dfa.DFA, ITokenStream, int, SimulatorState)
 		/// 	</see>
 		/// . When
 		/// <code>false</code>
@@ -288,13 +287,13 @@ namespace Antlr4.Runtime.Atn
 		{
 		}
 
-		public virtual int AdaptivePredict(TokenStream input, int decision, ParserRuleContext
+		public virtual int AdaptivePredict(ITokenStream input, int decision, ParserRuleContext
 			 outerContext)
 		{
 			return AdaptivePredict(input, decision, outerContext, false);
 		}
 
-		public virtual int AdaptivePredict(TokenStream input, int decision, ParserRuleContext
+		public virtual int AdaptivePredict(ITokenStream input, int decision, ParserRuleContext
 			 outerContext, bool useContext)
 		{
 			DFA dfa = atn.decisionToDFA[decision];
@@ -357,7 +356,7 @@ namespace Antlr4.Runtime.Atn
 			}
 		}
 
-		public virtual SimulatorState GetStartState(DFA dfa, TokenStream input, ParserRuleContext
+		public virtual SimulatorState GetStartState(DFA dfa, ITokenStream input, ParserRuleContext
 			 outerContext, bool useContext)
 		{
 			if (!useContext)
@@ -391,7 +390,7 @@ namespace Antlr4.Runtime.Atn
 			return new SimulatorState(outerContext, s0, useContext, remainingContext);
 		}
 
-		public virtual int PredictATN(DFA dfa, TokenStream input, ParserRuleContext outerContext
+		public virtual int PredictATN(DFA dfa, ITokenStream input, ParserRuleContext outerContext
 			, bool useContext)
 		{
 			if (outerContext == null)
@@ -425,7 +424,7 @@ namespace Antlr4.Runtime.Atn
 			return alt;
 		}
 
-		public virtual int ExecDFA(DFA dfa, TokenStream input, int startIndex, SimulatorState
+		public virtual int ExecDFA(DFA dfa, ITokenStream input, int startIndex, SimulatorState
 			 state)
 		{
 			ParserRuleContext outerContext = state.outerContext;
@@ -648,7 +647,7 @@ namespace Antlr4.Runtime.Atn
 		/// conflict + preds
 		/// TODO: greedy + those
 		/// </remarks>
-		public virtual int ExecATN(DFA dfa, TokenStream input, int startIndex, SimulatorState
+		public virtual int ExecATN(DFA dfa, ITokenStream input, int startIndex, SimulatorState
 			 initialState)
 		{
 			ParserRuleContext outerContext = initialState.outerContext;
@@ -795,7 +794,7 @@ namespace Antlr4.Runtime.Atn
 			}
 		}
 
-		protected internal virtual int HandleNoViableAlt(TokenStream input, int startIndex
+		protected internal virtual int HandleNoViableAlt(ITokenStream input, int startIndex
 			, SimulatorState previous)
 		{
 			if (previous.s0 != null)
@@ -1835,7 +1834,7 @@ namespace Antlr4.Runtime.Atn
 				{
 					System.Console.Error.WriteLine(t + " ttype out of range: " + Arrays.ToString(tokensNames
 						));
-					System.Console.Error.WriteLine(((CommonTokenStream)((TokenStream)parser.GetInputStream
+					System.Console.Error.WriteLine(((CommonTokenStream)((ITokenStream)parser.GetInputStream
 						())).GetTokens());
 				}
 				else
@@ -1846,7 +1845,7 @@ namespace Antlr4.Runtime.Atn
 			return t.ToString();
 		}
 
-		public virtual string GetLookaheadName(TokenStream input)
+		public virtual string GetLookaheadName(ITokenStream input)
 		{
 			return GetTokenName(input.La(1));
 		}
@@ -1880,7 +1879,7 @@ namespace Antlr4.Runtime.Atn
 		}
 
 		[NotNull]
-		public virtual NoViableAltException NoViableAlt(TokenStream input, ParserRuleContext
+		public virtual NoViableAltException NoViableAlt(ITokenStream input, ParserRuleContext
 			 outerContext, ATNConfigSet configs, int startIndex)
 		{
 			return new NoViableAltException(parser, input, input.Get(startIndex), input.Lt(1)
@@ -2085,12 +2084,12 @@ namespace Antlr4.Runtime.Atn
 			{
 				Interval interval = Interval.Of(startIndex, stopIndex);
 				System.Console.Out.WriteLine("reportAttemptingFullContext decision=" + dfa.decision
-					 + ":" + initialState.s0.configs + ", input=" + ((TokenStream)parser.GetInputStream
+					 + ":" + initialState.s0.configs + ", input=" + ((ITokenStream)parser.GetInputStream
 					()).GetText(interval));
 			}
 			if (parser != null)
 			{
-				((ParserErrorListener)parser.GetErrorListenerDispatch()).ReportAttemptingFullContext
+				((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportAttemptingFullContext
 					(parser, dfa, startIndex, stopIndex, initialState);
 			}
 		}
@@ -2102,12 +2101,12 @@ namespace Antlr4.Runtime.Atn
 			{
 				Interval interval = Interval.Of(startIndex, stopIndex);
 				System.Console.Out.WriteLine("reportContextSensitivity decision=" + dfa.decision 
-					+ ":" + acceptState.s0.configs + ", input=" + ((TokenStream)parser.GetInputStream
+					+ ":" + acceptState.s0.configs + ", input=" + ((ITokenStream)parser.GetInputStream
 					()).GetText(interval));
 			}
 			if (parser != null)
 			{
-				((ParserErrorListener)parser.GetErrorListenerDispatch()).ReportContextSensitivity
+				((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportContextSensitivity
 					(parser, dfa, startIndex, stopIndex, acceptState);
 			}
 		}
@@ -2136,11 +2135,11 @@ namespace Antlr4.Runtime.Atn
 				//			}
 				Interval interval = Interval.Of(startIndex, stopIndex);
 				System.Console.Out.WriteLine("reportAmbiguity " + ambigAlts + ":" + configs + ", input="
-					 + ((TokenStream)parser.GetInputStream()).GetText(interval));
+					 + ((ITokenStream)parser.GetInputStream()).GetText(interval));
 			}
 			if (parser != null)
 			{
-				((ParserErrorListener)parser.GetErrorListenerDispatch()).ReportAmbiguity(parser, 
+				((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportAmbiguity(parser, 
 					dfa, startIndex, stopIndex, ambigAlts, configs);
 			}
 		}
diff --git a/Antlr4.Runtime/BaseErrorListener.cs b/Antlr4.Runtime/BaseErrorListener.cs
index bfb24600a..6cb07b034 100644
--- a/Antlr4.Runtime/BaseErrorListener.cs
+++ b/Antlr4.Runtime/BaseErrorListener.cs
@@ -35,7 +35,7 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <author>Sam Harwell</author>
-	public class BaseErrorListener : ParserErrorListener
+	public class BaseErrorListener : IParserErrorListener
 	{
 		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
 			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
diff --git a/Antlr4.Runtime/BufferedTokenStream.cs b/Antlr4.Runtime/BufferedTokenStream.cs
index b80517723..171d6072b 100644
--- a/Antlr4.Runtime/BufferedTokenStream.cs
+++ b/Antlr4.Runtime/BufferedTokenStream.cs
@@ -64,10 +64,10 @@ namespace Antlr4.Runtime
 	/// because I don't want
 	/// to confuse small moving window of tokens it uses for the full buffer.
 	/// </remarks>
-	public class BufferedTokenStream : TokenStream
+	public class BufferedTokenStream : ITokenStream
 	{
 		[NotNull]
-		protected internal TokenSource tokenSource;
+		protected internal ITokenSource tokenSource;
 
 		/// <summary>
 		/// Record every single token pulled from the source so we can reproduce
@@ -113,7 +113,7 @@ namespace Antlr4.Runtime
 		/// <seealso cref="Fetch(int)">Fetch(int)</seealso>
 		protected internal bool fetchedEOF;
 
-		public BufferedTokenStream(TokenSource tokenSource)
+		public BufferedTokenStream(ITokenSource tokenSource)
 		{
 			if (tokenSource == null)
 			{
@@ -122,7 +122,7 @@ namespace Antlr4.Runtime
 			this.tokenSource = tokenSource;
 		}
 
-		public virtual TokenSource GetTokenSource()
+		public virtual ITokenSource GetTokenSource()
 		{
 			return tokenSource;
 		}
@@ -215,9 +215,9 @@ namespace Antlr4.Runtime
 			for (int i = 0; i < n; i++)
 			{
 				Token t = tokenSource.NextToken();
-				if (t is WritableToken)
+				if (t is IWritableToken)
 				{
-					((WritableToken)t).SetTokenIndex(tokens.Count);
+					((IWritableToken)t).SetTokenIndex(tokens.Count);
 				}
 				tokens.AddItem(t);
 				if (t.GetType() == Token.Eof)
@@ -344,7 +344,7 @@ namespace Antlr4.Runtime
 
 		/// <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(TokenSource tokenSource)
+		public virtual void SetTokenSource(ITokenSource tokenSource)
 		{
 			this.tokenSource = tokenSource;
 			tokens.Clear();
diff --git a/Antlr4.Runtime/CommonToken.cs b/Antlr4.Runtime/CommonToken.cs
index a2d6df1ea..49569b0a5 100644
--- a/Antlr4.Runtime/CommonToken.cs
+++ b/Antlr4.Runtime/CommonToken.cs
@@ -35,7 +35,7 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	[System.Serializable]
-	public class CommonToken : WritableToken
+	public class CommonToken : IWritableToken
 	{
 		private const long serialVersionUID = -6708843461296520577L;
 
@@ -47,7 +47,7 @@ namespace Antlr4.Runtime
 
 		protected internal int channel = DefaultChannel;
 
-		protected internal Tuple<TokenSource, CharStream> source;
+		protected internal Tuple<ITokenSource, CharStream> source;
 
 		/// <summary>We need to be able to change the text once in a while.</summary>
 		/// <remarks>
@@ -74,7 +74,7 @@ namespace Antlr4.Runtime
 			this.type = type;
 		}
 
-		public CommonToken(Tuple<TokenSource, CharStream> source, int type, int channel, 
+		public CommonToken(Tuple<ITokenSource, CharStream> source, int type, int channel, 
 			int start, int stop)
 		{
 			this.source = source;
@@ -220,7 +220,7 @@ namespace Antlr4.Runtime
 			this.index = index;
 		}
 
-		public virtual TokenSource GetTokenSource()
+		public virtual ITokenSource GetTokenSource()
 		{
 			return source.GetItem1();
 		}
diff --git a/Antlr4.Runtime/CommonTokenFactory.cs b/Antlr4.Runtime/CommonTokenFactory.cs
index d25bfe5c0..84f5f3449 100644
--- a/Antlr4.Runtime/CommonTokenFactory.cs
+++ b/Antlr4.Runtime/CommonTokenFactory.cs
@@ -34,9 +34,9 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public class CommonTokenFactory : TokenFactory
+	public class CommonTokenFactory : ITokenFactory
 	{
-		public static readonly TokenFactory Default = new Antlr4.Runtime.CommonTokenFactory
+		public static readonly ITokenFactory Default = new Antlr4.Runtime.CommonTokenFactory
 			();
 
 		/// <summary>Copy text for token out of input char stream.</summary>
@@ -65,7 +65,7 @@ namespace Antlr4.Runtime
 		}
 
 		public virtual CommonToken Create<_T0>(Tuple<_T0> source, int type, string text, 
-			int channel, int start, int stop, int line, int charPositionInLine) where _T0:TokenSource
+			int channel, int start, int stop, int line, int charPositionInLine) where _T0:ITokenSource
 		{
 			CommonToken t = new CommonToken(source, type, channel, start, stop);
 			t.SetLine(line);
diff --git a/Antlr4.Runtime/CommonTokenStream.cs b/Antlr4.Runtime/CommonTokenStream.cs
index 215d09bb0..55f0e6941 100644
--- a/Antlr4.Runtime/CommonTokenStream.cs
+++ b/Antlr4.Runtime/CommonTokenStream.cs
@@ -66,11 +66,11 @@ namespace Antlr4.Runtime
 		/// 	</remarks>
 		protected internal int channel = Token.DefaultChannel;
 
-		public CommonTokenStream(TokenSource tokenSource) : base(tokenSource)
+		public CommonTokenStream(ITokenSource tokenSource) : base(tokenSource)
 		{
 		}
 
-		public CommonTokenStream(TokenSource tokenSource, int channel) : this(tokenSource
+		public CommonTokenStream(ITokenSource tokenSource, int channel) : this(tokenSource
 			)
 		{
 			this.channel = channel;
diff --git a/Antlr4.Runtime/ConsoleErrorListener.cs b/Antlr4.Runtime/ConsoleErrorListener.cs
index e37a75e4c..ac7bc7841 100644
--- a/Antlr4.Runtime/ConsoleErrorListener.cs
+++ b/Antlr4.Runtime/ConsoleErrorListener.cs
@@ -33,7 +33,7 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <author>Sam Harwell</author>
-	public class ConsoleErrorListener : ANTLRErrorListener<object>
+	public class ConsoleErrorListener : IAntlrErrorListener<object>
 	{
 		public static readonly ConsoleErrorListener Instance = new ConsoleErrorListener();
 
diff --git a/Antlr4.Runtime/DefaultErrorStrategy.cs b/Antlr4.Runtime/DefaultErrorStrategy.cs
index 219a4e9be..baa7b6752 100644
--- a/Antlr4.Runtime/DefaultErrorStrategy.cs
+++ b/Antlr4.Runtime/DefaultErrorStrategy.cs
@@ -43,7 +43,7 @@ namespace Antlr4.Runtime
 	/// This is the default error handling mechanism for ANTLR parsers
 	/// and tree parsers.
 	/// </remarks>
-	public class DefaultErrorStrategy : ANTLRErrorStrategy
+	public class DefaultErrorStrategy : IAntlrErrorStrategy
 	{
 		/// <summary>
 		/// This is true after we see an error and before having successfully
@@ -145,7 +145,7 @@ namespace Antlr4.Runtime
 			//						   ", lastErrorIndex="+
 			//						   lastErrorIndex+
 			//						   ", states="+lastErrorStates);
-			if (lastErrorIndex == ((TokenStream)recognizer.GetInputStream()).Index() && lastErrorStates
+			if (lastErrorIndex == ((ITokenStream)recognizer.GetInputStream()).Index() && lastErrorStates
 				 != null && lastErrorStates.Contains(recognizer.GetState()))
 			{
 				// uh oh, another error at same token index and previously-visited
@@ -157,7 +157,7 @@ namespace Antlr4.Runtime
 				//			System.err.println("FAILSAFE consumes "+recognizer.getTokenNames()[recognizer.getInputStream().LA(1)]);
 				recognizer.Consume();
 			}
-			lastErrorIndex = ((TokenStream)recognizer.GetInputStream()).Index();
+			lastErrorIndex = ((ITokenStream)recognizer.GetInputStream()).Index();
 			if (lastErrorStates == null)
 			{
 				lastErrorStates = new IntervalSet();
@@ -193,7 +193,7 @@ namespace Antlr4.Runtime
 			{
 				return;
 			}
-			TokenStream tokens = ((TokenStream)recognizer.GetInputStream());
+			ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
 			int la = tokens.La(1);
 			// try cheaper subset first; might get lucky. seems to shave a wee bit off
 			if (recognizer.GetATN().NextTokens(s).Contains(la) || la == Token.Eof)
@@ -245,7 +245,7 @@ namespace Antlr4.Runtime
 		public virtual void ReportNoViableAlternative(Parser recognizer, NoViableAltException
 			 e)
 		{
-			TokenStream tokens = ((TokenStream)recognizer.GetInputStream());
+			ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
 			string input;
 			if (tokens != null)
 			{
@@ -363,7 +363,7 @@ namespace Antlr4.Runtime
 		// if next token is what we are looking for then "delete" this token
 		public virtual bool SingleTokenInsertion(Parser recognizer)
 		{
-			int currentSymbolType = ((TokenStream)recognizer.GetInputStream()).La(1);
+			int currentSymbolType = ((ITokenStream)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
 			// is free to conjure up and insert the missing token
@@ -384,7 +384,7 @@ namespace Antlr4.Runtime
 
 		public virtual Token SingleTokenDeletion(Parser recognizer)
 		{
-			int nextTokenType = ((TokenStream)recognizer.GetInputStream()).La(2);
+			int nextTokenType = ((ITokenStream)recognizer.GetInputStream()).La(2);
 			IntervalSet expecting = GetExpectedTokens(recognizer);
 			if (expecting.Contains(nextTokenType))
 			{
@@ -436,19 +436,19 @@ namespace Antlr4.Runtime
 				tokenText = "<missing " + recognizer.GetTokenNames()[expectedTokenType] + ">";
 			}
 			Token current = currentSymbol;
-			Token lookback = ((TokenStream)recognizer.GetInputStream()).Lt(-1);
+			Token lookback = ((ITokenStream)recognizer.GetInputStream()).Lt(-1);
 			if (current.GetType() == Token.Eof && lookback != null)
 			{
 				current = lookback;
 			}
-			return ConstructToken(((TokenStream)recognizer.GetInputStream()).GetTokenSource()
-				, expectedTokenType, tokenText, current);
+			return ConstructToken(((ITokenStream)recognizer.GetInputStream()).GetTokenSource(
+				), expectedTokenType, tokenText, current);
 		}
 
-		protected internal virtual Token ConstructToken(TokenSource tokenSource, int expectedTokenType
+		protected internal virtual Token ConstructToken(ITokenSource tokenSource, int expectedTokenType
 			, string tokenText, Token current)
 		{
-			TokenFactory factory = tokenSource.GetTokenFactory();
+			ITokenFactory factory = tokenSource.GetTokenFactory();
 			return factory.Create(Tuple.Create(tokenSource, current.GetTokenSource().GetInputStream
 				()), expectedTokenType, tokenText, Token.DefaultChannel, -1, -1, current.GetLine
 				(), current.GetCharPositionInLine());
@@ -536,13 +536,13 @@ namespace Antlr4.Runtime
 		public virtual void ConsumeUntil(Parser recognizer, IntervalSet set)
 		{
 			//		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
-			int ttype = ((TokenStream)recognizer.GetInputStream()).La(1);
+			int ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
 			while (ttype != Token.Eof && !set.Contains(ttype))
 			{
 				//System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
 				//			recognizer.getInputStream().consume();
 				recognizer.Consume();
-				ttype = ((TokenStream)recognizer.GetInputStream()).La(1);
+				ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
 			}
 		}
 	}
diff --git a/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs b/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
index c886d56dd..fbb41e9e3 100644
--- a/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
+++ b/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
@@ -35,7 +35,7 @@ using Sharpen;
 namespace Antlr4.Runtime.Dfa
 {
 	/// <author>Sam Harwell</author>
-	public abstract class AbstractEdgeMap<T> : EdgeMap<T>
+	public abstract class AbstractEdgeMap<T> : IEdgeMap<T>
 	{
 		protected internal readonly int minIndex;
 
@@ -51,8 +51,8 @@ namespace Antlr4.Runtime.Dfa
 
 		public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Put(int key, T value);
 
-		public virtual Antlr4.Runtime.Dfa.AbstractEdgeMap<T> PutAll<_T0>(EdgeMap<_T0> m) where 
-			_T0:T
+		public virtual Antlr4.Runtime.Dfa.AbstractEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m)
+			 where _T0:T
 		{
 			Antlr4.Runtime.Dfa.AbstractEdgeMap<T> result = this;
 			foreach (KeyValuePair<int, T> entry in m.EntrySet())
diff --git a/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs b/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
index 69fb4d6d5..8485a9b6d 100644
--- a/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
+++ b/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
@@ -96,7 +96,7 @@ namespace Antlr4.Runtime.Dfa
 			return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(key, null));
 		}
 
-		public override AbstractEdgeMap<T> PutAll<_T0>(EdgeMap<_T0> m)
+		public override AbstractEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m)
 		{
 			if (m.IsEmpty())
 			{
diff --git a/Antlr4.Runtime/Dfa/DFA.cs b/Antlr4.Runtime/Dfa/DFA.cs
index 0f8fdeb51..35cb3bcde 100644
--- a/Antlr4.Runtime/Dfa/DFA.cs
+++ b/Antlr4.Runtime/Dfa/DFA.cs
@@ -68,8 +68,8 @@ namespace Antlr4.Runtime.Dfa
 		/// <summary>
 		/// Set of configs for a DFA state with at least one conflict? Mainly used as "return value"
 		/// from
-		/// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.TokenStream, Antlr4.Runtime.ParserRuleContext, bool)
-		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.TokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+		/// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
 		/// 	</see>
 		/// for retry.
 		/// </summary>
diff --git a/Antlr4.Runtime/Dfa/EdgeMap.cs b/Antlr4.Runtime/Dfa/EdgeMap.cs
index e80d43f70..7931bc393 100644
--- a/Antlr4.Runtime/Dfa/EdgeMap.cs
+++ b/Antlr4.Runtime/Dfa/EdgeMap.cs
@@ -28,7 +28,6 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System.Collections.Generic;
-using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
 using Sharpen;
 
@@ -47,16 +46,16 @@ namespace Antlr4.Runtime.Dfa
 		T Get(int key);
 
 		[NotNull]
-		EdgeMap<T> Put(int key, T value);
+		IEdgeMap<T> Put(int key, T value);
 
 		[NotNull]
-		EdgeMap<T> Remove(int key);
+		IEdgeMap<T> Remove(int key);
 
 		[NotNull]
-		EdgeMap<T> PutAll<_T0>(EdgeMap<_T0> m) where _T0:T;
+		IEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m) where _T0:T;
 
 		[NotNull]
-		EdgeMap<T> Clear();
+		IEdgeMap<T> Clear();
 
 		[NotNull]
 		IDictionary<int, T> ToMap();
diff --git a/Antlr4.Runtime/DiagnosticErrorListener.cs b/Antlr4.Runtime/DiagnosticErrorListener.cs
index da09423a3..3382c220b 100644
--- a/Antlr4.Runtime/DiagnosticErrorListener.cs
+++ b/Antlr4.Runtime/DiagnosticErrorListener.cs
@@ -42,8 +42,8 @@ namespace Antlr4.Runtime
 		{
 			string format = "reportAmbiguity d=%s: ambigAlts=%s, input='%s'";
 			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
-				, dfa.decision), ambigAlts, ((TokenStream)recognizer.GetInputStream()).GetText(Interval
-				.Of(startIndex, stopIndex))));
+				, dfa.decision), ambigAlts, ((ITokenStream)recognizer.GetInputStream()).GetText(
+				Interval.Of(startIndex, stopIndex))));
 		}
 
 		public override void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int 
@@ -51,8 +51,8 @@ namespace Antlr4.Runtime
 		{
 			string format = "reportAttemptingFullContext d=%s, input='%s'";
 			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
-				, dfa.decision), ((TokenStream)recognizer.GetInputStream()).GetText(Interval.Of(
-				startIndex, stopIndex))));
+				, dfa.decision), ((ITokenStream)recognizer.GetInputStream()).GetText(Interval.Of
+				(startIndex, stopIndex))));
 		}
 
 		public override void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
@@ -60,8 +60,8 @@ namespace Antlr4.Runtime
 		{
 			string format = "reportContextSensitivity d=%s, input='%s'";
 			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
-				, dfa.decision), ((TokenStream)recognizer.GetInputStream()).GetText(Interval.Of(
-				startIndex, stopIndex))));
+				, dfa.decision), ((ITokenStream)recognizer.GetInputStream()).GetText(Interval.Of
+				(startIndex, stopIndex))));
 		}
 
 		protected internal virtual string GetDecisionDescription(Parser recognizer, int decision
diff --git a/Antlr4.Runtime/FailedPredicateException.cs b/Antlr4.Runtime/FailedPredicateException.cs
index b60a15567..2c015d5a8 100644
--- a/Antlr4.Runtime/FailedPredicateException.cs
+++ b/Antlr4.Runtime/FailedPredicateException.cs
@@ -62,7 +62,7 @@ namespace Antlr4.Runtime
 		}
 
 		public FailedPredicateException(Parser recognizer, string predicate, string message
-			) : base(FormatMessage(predicate, message), recognizer, ((TokenStream)recognizer
+			) : base(FormatMessage(predicate, message), recognizer, ((ITokenStream)recognizer
 			.GetInputStream()), recognizer._ctx)
 		{
 			ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
diff --git a/Antlr4.Runtime/InputMismatchException.cs b/Antlr4.Runtime/InputMismatchException.cs
index bc6961c34..dc3a8210b 100644
--- a/Antlr4.Runtime/InputMismatchException.cs
+++ b/Antlr4.Runtime/InputMismatchException.cs
@@ -45,7 +45,7 @@ namespace Antlr4.Runtime
 	{
 		private const long serialVersionUID = 1532568338707443067L;
 
-		public InputMismatchException(Parser recognizer) : base(recognizer, ((TokenStream
+		public InputMismatchException(Parser recognizer) : base(recognizer, ((ITokenStream
 			)recognizer.GetInputStream()), recognizer._ctx)
 		{
 			this.SetOffendingToken(recognizer.GetCurrentToken());
diff --git a/Antlr4.Runtime/Lexer.cs b/Antlr4.Runtime/Lexer.cs
index 7730e850a..df5ffb39c 100644
--- a/Antlr4.Runtime/Lexer.cs
+++ b/Antlr4.Runtime/Lexer.cs
@@ -44,7 +44,7 @@ namespace Antlr4.Runtime
 	/// uses simplified match() and error recovery mechanisms in the interest
 	/// of speed.
 	/// </remarks>
-	public abstract class Lexer : Recognizer<int, LexerATNSimulator>, TokenSource
+	public abstract class Lexer : Recognizer<int, LexerATNSimulator>, ITokenSource
 	{
 		public const int DefaultMode = 0;
 
@@ -62,10 +62,10 @@ namespace Antlr4.Runtime
 
 		public CharStream _input;
 
-		protected internal Tuple<TokenSource, CharStream> _tokenFactorySourcePair;
+		protected internal Tuple<ITokenSource, CharStream> _tokenFactorySourcePair;
 
 		/// <summary>How to create token objects</summary>
-		protected internal TokenFactory _factory = CommonTokenFactory.Default;
+		protected internal ITokenFactory _factory = CommonTokenFactory.Default;
 
 		/// <summary>The goal of all lexer rules/methods is to create a token object.</summary>
 		/// <remarks>
@@ -274,12 +274,12 @@ outer_break: ;
 			return _mode;
 		}
 
-		public virtual TokenFactory GetTokenFactory()
+		public virtual ITokenFactory GetTokenFactory()
 		{
 			return _factory;
 		}
 
-		public virtual void SetTokenFactory(TokenFactory factory)
+		public virtual void SetTokenFactory(ITokenFactory factory)
 		{
 			this._factory = factory;
 		}
@@ -492,7 +492,7 @@ outer_break: ;
 		{
 			string text = _input.GetText(Interval.Of(_tokenStartCharIndex, _input.Index()));
 			string msg = "token recognition error at: '" + GetErrorDisplay(text) + "'";
-			ANTLRErrorListener<int> listener = GetErrorListenerDispatch();
+			IAntlrErrorListener<int> listener = GetErrorListenerDispatch();
 			listener.SyntaxError(this, null, _tokenStartLine, _tokenStartCharPositionInLine, 
 				msg, e);
 		}
diff --git a/Antlr4.Runtime/Misc/IntSet.cs b/Antlr4.Runtime/Misc/IntSet.cs
index e51c9f899..602b6c068 100644
--- a/Antlr4.Runtime/Misc/IntSet.cs
+++ b/Antlr4.Runtime/Misc/IntSet.cs
@@ -28,7 +28,6 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System.Collections.Generic;
-using Antlr4.Runtime.Misc;
 using Sharpen;
 
 namespace Antlr4.Runtime.Misc
@@ -46,7 +45,7 @@ namespace Antlr4.Runtime.Misc
 		/// Add all elements from incoming set to this set.  Can limit
 		/// to set of its own type. Return "this" so we can chain calls.
 		/// </remarks>
-		IntSet AddAll(IntSet set);
+		IIntSet AddAll(IIntSet set);
 
 		/// <summary>
 		/// Return the intersection of this set with the argument, creating
@@ -56,13 +55,13 @@ namespace Antlr4.Runtime.Misc
 		/// Return the intersection of this set with the argument, creating
 		/// a new set.
 		/// </remarks>
-		IntSet And(IntSet a);
+		IIntSet And(IIntSet a);
 
-		IntSet Complement(IntSet elements);
+		IIntSet Complement(IIntSet elements);
 
-		IntSet Or(IntSet a);
+		IIntSet Or(IIntSet a);
 
-		IntSet Subtract(IntSet a);
+		IIntSet Subtract(IIntSet a);
 
 		/// <summary>
 		/// Return the size of this set (not the underlying implementation's
diff --git a/Antlr4.Runtime/Misc/IntervalSet.cs b/Antlr4.Runtime/Misc/IntervalSet.cs
index 7fe2cd04c..c68e545a1 100644
--- a/Antlr4.Runtime/Misc/IntervalSet.cs
+++ b/Antlr4.Runtime/Misc/IntervalSet.cs
@@ -53,7 +53,7 @@ namespace Antlr4.Runtime.Misc
 	/// 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.
 	/// </remarks>
-	public class IntervalSet : IntSet
+	public class IntervalSet : IIntSet
 	{
 		public static readonly Antlr4.Runtime.Misc.IntervalSet CompleteCharSet = Antlr4.Runtime.Misc.IntervalSet
 			.Of(0, Lexer.MaxCharValue);
@@ -219,7 +219,7 @@ namespace Antlr4.Runtime.Misc
 			return r;
 		}
 
-		public virtual Antlr4.Runtime.Misc.IntervalSet AddAll(IntSet set)
+		public virtual Antlr4.Runtime.Misc.IntervalSet AddAll(IIntSet set)
 		{
 			if (set == null)
 			{
@@ -259,7 +259,7 @@ namespace Antlr4.Runtime.Misc
 		/// this.  The computation is (vocabulary - this).
 		/// 'this' is assumed to be either a subset or equal to vocabulary.
 		/// </remarks>
-		public virtual Antlr4.Runtime.Misc.IntervalSet Complement(IntSet vocabulary)
+		public virtual Antlr4.Runtime.Misc.IntervalSet Complement(IIntSet vocabulary)
 		{
 			if (vocabulary == null)
 			{
@@ -318,7 +318,7 @@ namespace Antlr4.Runtime.Misc
 		/// other is assumed to be a subset of this;
 		/// anything that is in other but not in this will be ignored.
 		/// </remarks>
-		public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IntSet other)
+		public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet other)
 		{
 			// assume the whole unicode range here for the complement
 			// because it doesn't matter.  Anything beyond the max of this' set
@@ -330,7 +330,7 @@ namespace Antlr4.Runtime.Misc
 				));
 		}
 
-		public virtual Antlr4.Runtime.Misc.IntervalSet Or(IntSet a)
+		public virtual Antlr4.Runtime.Misc.IntervalSet Or(IIntSet a)
 		{
 			Antlr4.Runtime.Misc.IntervalSet o = new Antlr4.Runtime.Misc.IntervalSet();
 			o.AddAll(this);
@@ -345,7 +345,7 @@ namespace Antlr4.Runtime.Misc
 		/// just walk them together.  This is roughly O(min(n,m)) for interval
 		/// list lengths n and m.
 		/// </remarks>
-		public virtual Antlr4.Runtime.Misc.IntervalSet And(IntSet other)
+		public virtual Antlr4.Runtime.Misc.IntervalSet And(IIntSet other)
 		{
 			if (other == null)
 			{
diff --git a/Antlr4.Runtime/Misc/TestRig.cs b/Antlr4.Runtime/Misc/TestRig.cs
index 9d8dbaf4a..b4cfc0969 100644
--- a/Antlr4.Runtime/Misc/TestRig.cs
+++ b/Antlr4.Runtime/Misc/TestRig.cs
@@ -214,8 +214,8 @@ namespace Antlr4.Runtime.Misc
 				{
 					System.Console.Error.WriteLine("Can't load " + parserName);
 				}
-				Constructor<Parser> parserCtor = parserClass.GetConstructor(typeof(TokenStream));
-				parser = parserCtor.NewInstance((TokenStream)null);
+				Constructor<Parser> parserCtor = parserClass.GetConstructor(typeof(ITokenStream));
+				parser = parserCtor.NewInstance((ITokenStream)null);
 			}
 			if (inputFiles.IsEmpty())
 			{
diff --git a/Antlr4.Runtime/NoViableAltException.cs b/Antlr4.Runtime/NoViableAltException.cs
index e075d2d4b..4bc389728 100644
--- a/Antlr4.Runtime/NoViableAltException.cs
+++ b/Antlr4.Runtime/NoViableAltException.cs
@@ -67,13 +67,13 @@ namespace Antlr4.Runtime
 		[NotNull]
 		private readonly Token startToken;
 
-		public NoViableAltException(Parser recognizer) : this(recognizer, ((TokenStream)recognizer
-			.GetInputStream()), recognizer.GetCurrentToken(), recognizer.GetCurrentToken(), 
-			null, recognizer._ctx)
+		public NoViableAltException(Parser recognizer) : this(recognizer, ((ITokenStream)
+			recognizer.GetInputStream()), recognizer.GetCurrentToken(), recognizer.GetCurrentToken
+			(), null, recognizer._ctx)
 		{
 		}
 
-		public NoViableAltException(Recognizer<Token, object> recognizer, TokenStream input
+		public NoViableAltException(Recognizer<Token, object> recognizer, ITokenStream input
 			, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext
 			 ctx) : base(recognizer, input, ctx)
 		{
diff --git a/Antlr4.Runtime/Parser.cs b/Antlr4.Runtime/Parser.cs
index 5f3356283..1c6d9ddb0 100644
--- a/Antlr4.Runtime/Parser.cs
+++ b/Antlr4.Runtime/Parser.cs
@@ -33,7 +33,6 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime
@@ -44,7 +43,7 @@ namespace Antlr4.Runtime
 	/// 	</remarks>
 	public abstract class Parser : Recognizer<Token, ParserATNSimulator>
 	{
-		public class TraceListener : ParseTreeListener
+		public class TraceListener : IParseTreeListener
 		{
 			public virtual void EnterEveryRule(ParserRuleContext ctx)
 			{
@@ -58,11 +57,11 @@ namespace Antlr4.Runtime
 					()] + ", LT(1)=" + this._enclosing._input.Lt(1).GetText());
 			}
 
-			public virtual void VisitErrorNode(ErrorNode node)
+			public virtual void VisitErrorNode(IErrorNode node)
 			{
 			}
 
-			public virtual void VisitTerminal(TerminalNode node)
+			public virtual void VisitTerminal(ITerminalNode node)
 			{
 				ParserRuleContext parent = (ParserRuleContext)node.GetParent().GetRuleContext();
 				Token token = node.GetSymbol();
@@ -78,16 +77,16 @@ namespace Antlr4.Runtime
 			private readonly Parser _enclosing;
 		}
 
-		public class TrimToSizeListener : ParseTreeListener
+		public class TrimToSizeListener : IParseTreeListener
 		{
 			public static readonly Parser.TrimToSizeListener Instance = new Parser.TrimToSizeListener
 				();
 
-			public virtual void VisitTerminal(TerminalNode node)
+			public virtual void VisitTerminal(ITerminalNode node)
 			{
 			}
 
-			public virtual void VisitErrorNode(ErrorNode node)
+			public virtual void VisitErrorNode(IErrorNode node)
 			{
 			}
 
@@ -104,9 +103,9 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		protected internal ANTLRErrorStrategy _errHandler = new DefaultErrorStrategy();
+		protected internal IAntlrErrorStrategy _errHandler = new DefaultErrorStrategy();
 
-		protected internal TokenStream _input;
+		protected internal ITokenStream _input;
 
 		protected internal readonly IntegerStack _precedenceStack;
 
@@ -137,13 +136,13 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		/// <seealso cref="Antlr4.Runtime.Tree.ParseTreeWalker">Antlr4.Runtime.Tree.ParseTreeWalker
 		/// 	</seealso>
-		protected internal IList<ParseTreeListener> _parseListeners;
+		protected internal IList<IParseTreeListener> _parseListeners;
 
 		/// <summary>Did the recognizer encounter a syntax error?  Track how many.</summary>
 		/// <remarks>Did the recognizer encounter a syntax error?  Track how many.</remarks>
 		protected internal int _syntaxErrors = 0;
 
-		public Parser(TokenStream input)
+		public Parser(ITokenStream input)
 		{
 			{
 				_precedenceStack = new IntegerStack();
@@ -155,9 +154,9 @@ namespace Antlr4.Runtime
 		/// <summary>reset the parser's state</summary>
 		public virtual void Reset()
 		{
-			if (((TokenStream)GetInputStream()) != null)
+			if (((ITokenStream)GetInputStream()) != null)
 			{
-				((TokenStream)GetInputStream()).Seek(0);
+				((ITokenStream)GetInputStream()).Seek(0);
 			}
 			_errHandler.EndErrorCondition(this);
 			_ctx = null;
@@ -311,7 +310,7 @@ namespace Antlr4.Runtime
 		//	public boolean getTraceATNStates() {
 		//		return traceATNStates;
 		//	}
-		public virtual IList<ParseTreeListener> GetParseListeners()
+		public virtual IList<IParseTreeListener> GetParseListeners()
 		{
 			return _parseListeners;
 		}
@@ -329,7 +328,7 @@ namespace Antlr4.Runtime
 		/// ParseTreeListener to a ParseTreeWalker instead of giving it to
 		/// the parser!!!!
 		/// </remarks>
-		public virtual void AddParseListener(ParseTreeListener listener)
+		public virtual void AddParseListener(IParseTreeListener listener)
 		{
 			if (listener == null)
 			{
@@ -337,12 +336,12 @@ namespace Antlr4.Runtime
 			}
 			if (_parseListeners == null)
 			{
-				_parseListeners = new AList<ParseTreeListener>();
+				_parseListeners = new AList<IParseTreeListener>();
 			}
 			this._parseListeners.AddItem(listener);
 		}
 
-		public virtual void RemoveParseListener(ParseTreeListener l)
+		public virtual void RemoveParseListener(IParseTreeListener l)
 		{
 			if (l == null)
 			{
@@ -375,7 +374,7 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		public virtual void TriggerEnterRuleEvent()
 		{
-			foreach (ParseTreeListener l in _parseListeners)
+			foreach (IParseTreeListener l in _parseListeners)
 			{
 				l.EnterEveryRule(_ctx);
 				_ctx.EnterRule(l);
@@ -397,7 +396,7 @@ namespace Antlr4.Runtime
 			// reverse order walk of listeners
 			for (int i = _parseListeners.Count - 1; i >= 0; i--)
 			{
-				ParseTreeListener l = _parseListeners[i];
+				IParseTreeListener l = _parseListeners[i];
 				_ctx.ExitRule(l);
 				l.ExitEveryRule(_ctx);
 			}
@@ -416,12 +415,12 @@ namespace Antlr4.Runtime
 			return _syntaxErrors;
 		}
 
-		public virtual ANTLRErrorStrategy GetErrorHandler()
+		public virtual IAntlrErrorStrategy GetErrorHandler()
 		{
 			return _errHandler;
 		}
 
-		public virtual void SetErrorHandler(ANTLRErrorStrategy handler)
+		public virtual void SetErrorHandler(IAntlrErrorStrategy handler)
 		{
 			this._errHandler = handler;
 		}
@@ -432,7 +431,7 @@ namespace Antlr4.Runtime
 		}
 
 		/// <summary>Set the token stream and reset the parser</summary>
-		public virtual void SetInputStream(TokenStream input)
+		public virtual void SetInputStream(ITokenStream input)
 		{
 			this._input = null;
 			Reset();
@@ -467,7 +466,7 @@ namespace Antlr4.Runtime
 				line = offendingToken.GetLine();
 				charPositionInLine = offendingToken.GetCharPositionInLine();
 			}
-			ANTLRErrorListener<Token> listener = ((ParserErrorListener)GetErrorListenerDispatch
+			IAntlrErrorListener<Token> listener = ((IParserErrorListener)GetErrorListenerDispatch
 				());
 			listener.SyntaxError(this, offendingToken, line, charPositionInLine, msg, e);
 		}
@@ -488,17 +487,17 @@ namespace Antlr4.Runtime
 			Token o = GetCurrentToken();
 			if (o.GetType() != Eof)
 			{
-				((TokenStream)GetInputStream()).Consume();
+				((ITokenStream)GetInputStream()).Consume();
 			}
 			bool hasListener = _parseListeners != null && !_parseListeners.IsEmpty();
 			if (_buildParseTrees || hasListener)
 			{
 				if (_errHandler.InErrorRecoveryMode(this))
 				{
-					ErrorNode node = _ctx.AddErrorNode(o);
+					IErrorNode node = _ctx.AddErrorNode(o);
 					if (_parseListeners != null)
 					{
-						foreach (ParseTreeListener listener in _parseListeners)
+						foreach (IParseTreeListener listener in _parseListeners)
 						{
 							listener.VisitErrorNode(node);
 						}
@@ -506,10 +505,10 @@ namespace Antlr4.Runtime
 				}
 				else
 				{
-					TerminalNode node = _ctx.AddChild(o);
+					ITerminalNode node = _ctx.AddChild(o);
 					if (_parseListeners != null)
 					{
-						foreach (ParseTreeListener listener in _parseListeners)
+						foreach (IParseTreeListener listener in _parseListeners)
 						{
 							listener.VisitTerminal(node);
 						}
@@ -691,7 +690,7 @@ namespace Antlr4.Runtime
 			return precedence >= _precedenceStack.Peek();
 		}
 
-		public override ANTLRErrorListener<Token> GetErrorListenerDispatch()
+		public override IAntlrErrorListener<Token> GetErrorListenerDispatch()
 		{
 			return new ProxyParserErrorListener(GetErrorListeners());
 		}
diff --git a/Antlr4.Runtime/ParserErrorListener.cs b/Antlr4.Runtime/ParserErrorListener.cs
index 484647218..5bf5c0dee 100644
--- a/Antlr4.Runtime/ParserErrorListener.cs
+++ b/Antlr4.Runtime/ParserErrorListener.cs
@@ -35,7 +35,7 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <summary>How to emit recognition errors</summary>
-	public interface ParserErrorListener : ANTLRErrorListener<Token>
+	public interface ParserErrorListener : IAntlrErrorListener<Token>
 	{
 		/// <summary>
 		/// Called when the parser detects a true ambiguity: an input sequence can be matched
diff --git a/Antlr4.Runtime/ParserRuleContext.cs b/Antlr4.Runtime/ParserRuleContext.cs
index e24e1bc2e..0ce8e34c3 100644
--- a/Antlr4.Runtime/ParserRuleContext.cs
+++ b/Antlr4.Runtime/ParserRuleContext.cs
@@ -74,7 +74,7 @@ namespace Antlr4.Runtime
 		/// operation because we don't the need to track the details about
 		/// how we parse this rule.
 		/// </remarks>
-		public IList<ParseTree> children;
+		public IList<IParseTree> children;
 
 		/// <summary>
 		/// For debugging/tracing purposes, we want to track all of the nodes in
@@ -159,20 +159,20 @@ namespace Antlr4.Runtime
 		}
 
 		// Double dispatch methods for listeners
-		public virtual void EnterRule(ParseTreeListener listener)
+		public virtual void EnterRule(IParseTreeListener listener)
 		{
 		}
 
-		public virtual void ExitRule(ParseTreeListener listener)
+		public virtual void ExitRule(IParseTreeListener listener)
 		{
 		}
 
 		/// <summary>Does not set parent link; other add methods do that</summary>
-		public virtual void AddChild(TerminalNode t)
+		public virtual void AddChild(ITerminalNode t)
 		{
 			if (children == null)
 			{
-				children = new AList<ParseTree>();
+				children = new AList<IParseTree>();
 			}
 			children.AddItem(t);
 		}
@@ -181,7 +181,7 @@ namespace Antlr4.Runtime
 		{
 			if (children == null)
 			{
-				children = new AList<ParseTree>();
+				children = new AList<IParseTree>();
 			}
 			children.AddItem(ruleInvocation);
 		}
@@ -207,7 +207,7 @@ namespace Antlr4.Runtime
 		//		if ( states==null ) states = new ArrayList<Integer>();
 		//		states.add(s);
 		//	}
-		public virtual TerminalNode AddChild(Token matchedToken)
+		public virtual ITerminalNode AddChild(Token matchedToken)
 		{
 			TerminalNodeImpl t = new TerminalNodeImpl(matchedToken);
 			AddChild(t);
@@ -215,7 +215,7 @@ namespace Antlr4.Runtime
 			return t;
 		}
 
-		public virtual ErrorNode AddErrorNode(Token badToken)
+		public virtual IErrorNode AddErrorNode(Token badToken)
 		{
 			ErrorNodeImpl t = new ErrorNodeImpl(badToken);
 			AddChild(t);
@@ -228,12 +228,12 @@ namespace Antlr4.Runtime
 			return (Antlr4.Runtime.ParserRuleContext)base.GetParent();
 		}
 
-		public override ParseTree GetChild(int i)
+		public override IParseTree GetChild(int i)
 		{
 			return children != null && i >= 0 && i < children.Count ? children[i] : null;
 		}
 
-		public virtual T GetChild<T, _T1>(Type<_T1> ctxType, int i) where T:ParseTree where 
+		public virtual T GetChild<T, _T1>(Type<_T1> ctxType, int i) where T:IParseTree where 
 			_T1:T
 		{
 			if (children == null || i < 0 || i >= children.Count)
@@ -242,7 +242,7 @@ namespace Antlr4.Runtime
 			}
 			int j = -1;
 			// what element have we found with ctxType?
-			foreach (ParseTree o in children)
+			foreach (IParseTree o in children)
 			{
 				if (ctxType.IsInstanceOfType(o))
 				{
@@ -256,7 +256,7 @@ namespace Antlr4.Runtime
 			return null;
 		}
 
-		public virtual TerminalNode GetToken(int ttype, int i)
+		public virtual ITerminalNode GetToken(int ttype, int i)
 		{
 			if (children == null || i < 0 || i >= children.Count)
 			{
@@ -264,11 +264,11 @@ namespace Antlr4.Runtime
 			}
 			int j = -1;
 			// what token with ttype have we found?
-			foreach (ParseTree o in children)
+			foreach (IParseTree o in children)
 			{
-				if (o is TerminalNode)
+				if (o is ITerminalNode)
 				{
-					TerminalNode tnode = (TerminalNode)o;
+					ITerminalNode tnode = (ITerminalNode)o;
 					Token symbol = tnode.GetSymbol();
 					if (symbol.GetType() == ttype)
 					{
@@ -283,24 +283,24 @@ namespace Antlr4.Runtime
 			return null;
 		}
 
-		public virtual IList<TerminalNode> GetTokens(int ttype)
+		public virtual IList<ITerminalNode> GetTokens(int ttype)
 		{
 			if (children == null)
 			{
 				return Sharpen.Collections.EmptyList();
 			}
-			IList<TerminalNode> tokens = null;
-			foreach (ParseTree o in children)
+			IList<ITerminalNode> tokens = null;
+			foreach (IParseTree o in children)
 			{
-				if (o is TerminalNode)
+				if (o is ITerminalNode)
 				{
-					TerminalNode tnode = (TerminalNode)o;
+					ITerminalNode tnode = (ITerminalNode)o;
 					Token symbol = tnode.GetSymbol();
 					if (symbol.GetType() == ttype)
 					{
 						if (tokens == null)
 						{
-							tokens = new AList<TerminalNode>();
+							tokens = new AList<ITerminalNode>();
 						}
 						tokens.AddItem(tnode);
 					}
@@ -327,7 +327,7 @@ namespace Antlr4.Runtime
 				return Sharpen.Collections.EmptyList();
 			}
 			IList<T> contexts = null;
-			foreach (ParseTree o in children)
+			foreach (IParseTree o in children)
 			{
 				if (ctxType.IsInstanceOfType(o))
 				{
diff --git a/Antlr4.Runtime/ProxyErrorListener.cs b/Antlr4.Runtime/ProxyErrorListener.cs
index 7da11c1fe..b24e400eb 100644
--- a/Antlr4.Runtime/ProxyErrorListener.cs
+++ b/Antlr4.Runtime/ProxyErrorListener.cs
@@ -34,16 +34,17 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <author>Sam Harwell</author>
-	public class ProxyErrorListener<Symbol> : ANTLRErrorListener<Symbol>
+	public class ProxyErrorListener<Symbol> : IAntlrErrorListener<Symbol>
 	{
-		private readonly ICollection<ANTLRErrorListener<Symbol>> delegates;
+		private readonly ICollection<IAntlrErrorListener<Symbol>> delegates;
 
-		public ProxyErrorListener(ICollection<ANTLRErrorListener<Symbol>> delegates)
+		public ProxyErrorListener(ICollection<IAntlrErrorListener<Symbol>> delegates)
 		{
 			this.delegates = delegates;
 		}
 
-		protected internal virtual ICollection<ANTLRErrorListener<Symbol>> GetDelegates()
+		protected internal virtual ICollection<IAntlrErrorListener<Symbol>> GetDelegates(
+			)
 		{
 			return delegates;
 		}
@@ -52,7 +53,7 @@ namespace Antlr4.Runtime
 			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
 			Symbol
 		{
-			foreach (ANTLRErrorListener<Symbol> listener in delegates)
+			foreach (IAntlrErrorListener<Symbol> listener in delegates)
 			{
 				listener.SyntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, 
 					e);
diff --git a/Antlr4.Runtime/ProxyParserErrorListener.cs b/Antlr4.Runtime/ProxyParserErrorListener.cs
index 4025d470b..9168835f4 100644
--- a/Antlr4.Runtime/ProxyParserErrorListener.cs
+++ b/Antlr4.Runtime/ProxyParserErrorListener.cs
@@ -36,23 +36,23 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <author>Sam Harwell</author>
-	public class ProxyParserErrorListener : ProxyErrorListener<Token>, ParserErrorListener
+	public class ProxyParserErrorListener : ProxyErrorListener<Token>, IParserErrorListener
 	{
-		public ProxyParserErrorListener(ICollection<ANTLRErrorListener<Token>> delegates)
-			 : base(delegates)
+		public ProxyParserErrorListener(ICollection<IAntlrErrorListener<Token>> delegates
+			) : base(delegates)
 		{
 		}
 
 		public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
 			 stopIndex, BitSet ambigAlts, ATNConfigSet configs)
 		{
-			foreach (ANTLRErrorListener<Token> listener in GetDelegates())
+			foreach (IAntlrErrorListener<Token> listener in GetDelegates())
 			{
-				if (!(listener is ParserErrorListener))
+				if (!(listener is IParserErrorListener))
 				{
 					continue;
 				}
-				ParserErrorListener parserErrorListener = (ParserErrorListener)listener;
+				IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
 				parserErrorListener.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, ambigAlts
 					, configs);
 			}
@@ -61,13 +61,13 @@ namespace Antlr4.Runtime
 		public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
 			, int stopIndex, SimulatorState initialState)
 		{
-			foreach (ANTLRErrorListener<Token> listener in GetDelegates())
+			foreach (IAntlrErrorListener<Token> listener in GetDelegates())
 			{
-				if (!(listener is ParserErrorListener))
+				if (!(listener is IParserErrorListener))
 				{
 					continue;
 				}
-				ParserErrorListener parserErrorListener = (ParserErrorListener)listener;
+				IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
 				parserErrorListener.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex
 					, initialState);
 			}
@@ -76,13 +76,13 @@ namespace Antlr4.Runtime
 		public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
 			, int stopIndex, SimulatorState acceptState)
 		{
-			foreach (ANTLRErrorListener<Token> listener in GetDelegates())
+			foreach (IAntlrErrorListener<Token> listener in GetDelegates())
 			{
-				if (!(listener is ParserErrorListener))
+				if (!(listener is IParserErrorListener))
 				{
 					continue;
 				}
-				ParserErrorListener parserErrorListener = (ParserErrorListener)listener;
+				IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
 				parserErrorListener.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex
 					, acceptState);
 			}
diff --git a/Antlr4.Runtime/Recognizer.cs b/Antlr4.Runtime/Recognizer.cs
index 30189dbb3..258ce4b27 100644
--- a/Antlr4.Runtime/Recognizer.cs
+++ b/Antlr4.Runtime/Recognizer.cs
@@ -39,7 +39,7 @@ namespace Antlr4.Runtime
 	{
 		public const int Eof = -1;
 
-		private sealed class _CopyOnWriteArrayList_49 : CopyOnWriteArrayList<ANTLRErrorListener
+		private sealed class _CopyOnWriteArrayList_49 : CopyOnWriteArrayList<IAntlrErrorListener
 			<Symbol>>
 		{
 			public _CopyOnWriteArrayList_49()
@@ -51,7 +51,7 @@ namespace Antlr4.Runtime
 		}
 
 		[NotNull]
-		private IList<ANTLRErrorListener<Symbol>> _listeners = new _CopyOnWriteArrayList_49
+		private IList<IAntlrErrorListener<Symbol>> _listeners = new _CopyOnWriteArrayList_49
 			();
 
 		protected internal ATNInterpreter _interp;
@@ -146,13 +146,13 @@ namespace Antlr4.Runtime
 		/// <code>null</code>
 		/// .
 		/// </exception>
-		public virtual void AddErrorListener<_T0>(ANTLRErrorListener<_T0> listener)
+		public virtual void AddErrorListener<_T0>(IAntlrErrorListener<_T0> listener)
 		{
 			Args.NotNull("listener", listener);
 			_listeners.AddItem(listener);
 		}
 
-		public virtual void RemoveErrorListener<_T0>(ANTLRErrorListener<_T0> listener)
+		public virtual void RemoveErrorListener<_T0>(IAntlrErrorListener<_T0> listener)
 		{
 			_listeners.Remove(listener);
 		}
@@ -163,12 +163,12 @@ namespace Antlr4.Runtime
 		}
 
 		[NotNull]
-		public virtual IList<ANTLRErrorListener<Symbol>> GetErrorListeners()
+		public virtual IList<IAntlrErrorListener<Symbol>> GetErrorListeners()
 		{
-			return new AList<ANTLRErrorListener<Symbol>>(_listeners);
+			return new AList<IAntlrErrorListener<Symbol>>(_listeners);
 		}
 
-		public virtual ANTLRErrorListener<Symbol> GetErrorListenerDispatch()
+		public virtual IAntlrErrorListener<Symbol> GetErrorListenerDispatch()
 		{
 			return new ProxyErrorListener<Symbol>(GetErrorListeners());
 		}
diff --git a/Antlr4.Runtime/RuleContext.cs b/Antlr4.Runtime/RuleContext.cs
index f64af55af..666c26033 100644
--- a/Antlr4.Runtime/RuleContext.cs
+++ b/Antlr4.Runtime/RuleContext.cs
@@ -57,7 +57,7 @@ namespace Antlr4.Runtime
 	/// ParserRuleContext.
 	/// </remarks>
 	/// <seealso cref="ParserRuleContext">ParserRuleContext</seealso>
-	public class RuleContext : RuleNode
+	public class RuleContext : IRuleNode
 	{
 		/// <summary>What context invoked this rule?</summary>
 		public Antlr4.Runtime.RuleContext parent;
@@ -165,7 +165,7 @@ namespace Antlr4.Runtime
 			return -1;
 		}
 
-		public virtual ParseTree GetChild(int i)
+		public virtual IParseTree GetChild(int i)
 		{
 			return null;
 		}
@@ -175,7 +175,7 @@ namespace Antlr4.Runtime
 			return 0;
 		}
 
-		public virtual T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor) where _T1:T
+		public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
 		{
 			return visitor.VisitChildren(this);
 		}
diff --git a/Antlr4.Runtime/Token.cs b/Antlr4.Runtime/Token.cs
index cd3cb4c25..8141edaef 100644
--- a/Antlr4.Runtime/Token.cs
+++ b/Antlr4.Runtime/Token.cs
@@ -136,10 +136,10 @@ namespace Antlr4.Runtime
 
 		/// <summary>
 		/// Gets the
-		/// <see cref="TokenSource">TokenSource</see>
+		/// <see cref="ITokenSource">ITokenSource</see>
 		/// which created this token.
 		/// </summary>
-		public abstract TokenSource GetTokenSource();
+		public abstract ITokenSource GetTokenSource();
 
 		/// <summary>
 		/// Gets the
diff --git a/Antlr4.Runtime/TokenFactory.cs b/Antlr4.Runtime/TokenFactory.cs
index e77c4f7ad..686986ac2 100644
--- a/Antlr4.Runtime/TokenFactory.cs
+++ b/Antlr4.Runtime/TokenFactory.cs
@@ -51,7 +51,7 @@ namespace Antlr4.Runtime
 		/// are wiped to -1 in the text override is set in the CommonToken.
 		/// </remarks>
 		Token Create<_T0>(Tuple<_T0> source, int type, string text, int channel, int start
-			, int stop, int line, int charPositionInLine) where _T0:TokenSource;
+			, int stop, int line, int charPositionInLine) where _T0:ITokenSource;
 
 		/// <summary>Generically useful</summary>
 		Token Create(int type, string text);
diff --git a/Antlr4.Runtime/TokenSource.cs b/Antlr4.Runtime/TokenSource.cs
index 0e5686b27..e3c0aaba8 100644
--- a/Antlr4.Runtime/TokenSource.cs
+++ b/Antlr4.Runtime/TokenSource.cs
@@ -88,9 +88,9 @@ namespace Antlr4.Runtime
 
 		/// <summary>Gets the factory used for constructing tokens.</summary>
 		/// <remarks>Gets the factory used for constructing tokens.</remarks>
-		TokenFactory GetTokenFactory();
+		ITokenFactory GetTokenFactory();
 
 		/// <summary>Optional method that lets users set factory in lexer or other source</summary>
-		void SetTokenFactory(TokenFactory factory);
+		void SetTokenFactory(ITokenFactory factory);
 	}
 }
diff --git a/Antlr4.Runtime/TokenStream.cs b/Antlr4.Runtime/TokenStream.cs
index 29fd1cd22..9c3f17381 100644
--- a/Antlr4.Runtime/TokenStream.cs
+++ b/Antlr4.Runtime/TokenStream.cs
@@ -100,12 +100,12 @@ namespace Antlr4.Runtime
 
 		/// <summary>
 		/// Gets the underlying
-		/// <see cref="TokenSource">TokenSource</see>
+		/// <see cref="ITokenSource">ITokenSource</see>
 		/// which provides tokens for this
 		/// stream.
 		/// </summary>
 		[NotNull]
-		TokenSource GetTokenSource();
+		ITokenSource GetTokenSource();
 
 		/// <summary>
 		/// Return the text of all tokens within the specified
diff --git a/Antlr4.Runtime/TokenStreamRewriter.cs b/Antlr4.Runtime/TokenStreamRewriter.cs
index 8e8fc19cd..602da1199 100644
--- a/Antlr4.Runtime/TokenStreamRewriter.cs
+++ b/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -102,7 +102,7 @@ namespace Antlr4.Runtime
 
 		public class RewriteOperation
 		{
-			protected internal readonly TokenStream tokens;
+			protected internal readonly ITokenStream tokens;
 
 			/// <summary>What index into rewrites List are we?</summary>
 			protected internal int instructionIndex;
@@ -113,14 +113,14 @@ namespace Antlr4.Runtime
 
 			protected internal object text;
 
-			protected internal RewriteOperation(TokenStream tokens, int index)
+			protected internal RewriteOperation(ITokenStream tokens, int index)
 			{
 				// Define the rewrite operation hierarchy
 				this.tokens = tokens;
 				this.index = index;
 			}
 
-			protected internal RewriteOperation(TokenStream tokens, int index, object text)
+			protected internal RewriteOperation(ITokenStream tokens, int index, object text)
 			{
 				this.tokens = tokens;
 				this.index = index;
@@ -148,8 +148,8 @@ namespace Antlr4.Runtime
 
 		internal class InsertBeforeOp : TokenStreamRewriter.RewriteOperation
 		{
-			protected internal InsertBeforeOp(TokenStream tokens, int index, object text) : base
-				(tokens, index, text)
+			protected internal InsertBeforeOp(ITokenStream tokens, int index, object text) : 
+				base(tokens, index, text)
 			{
 			}
 
@@ -176,7 +176,7 @@ namespace Antlr4.Runtime
 		{
 			protected internal int lastIndex;
 
-			public ReplaceOp(TokenStream tokens, int from, int to, object text) : base(tokens
+			public ReplaceOp(ITokenStream tokens, int from, int to, object text) : base(tokens
 				, from, text)
 			{
 				lastIndex = to;
@@ -203,7 +203,7 @@ namespace Antlr4.Runtime
 		}
 
 		/// <summary>Our source stream</summary>
-		protected internal readonly TokenStream tokens;
+		protected internal readonly ITokenStream tokens;
 
 		/// <summary>You may have multiple, named streams of rewrite operations.</summary>
 		/// <remarks>
@@ -217,7 +217,7 @@ namespace Antlr4.Runtime
 		/// <summary>Map String (program name) -&gt; Integer index</summary>
 		protected internal readonly IDictionary<string, int> lastRewriteTokenIndexes;
 
-		public TokenStreamRewriter(TokenStream tokens)
+		public TokenStreamRewriter(ITokenStream tokens)
 		{
 			this.tokens = tokens;
 			programs = new Dictionary<string, IList<TokenStreamRewriter.RewriteOperation>>();
@@ -226,7 +226,7 @@ namespace Antlr4.Runtime
 			lastRewriteTokenIndexes = new Dictionary<string, int>();
 		}
 
-		public TokenStream GetTokenStream()
+		public ITokenStream GetTokenStream()
 		{
 			return tokens;
 		}
diff --git a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
index c2f9e078c..49c80b829 100644
--- a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
+++ b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
@@ -32,18 +32,19 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public abstract class AbstractParseTreeVisitor<Result> : ParseTreeVisitor<Result>
+	public abstract class AbstractParseTreeVisitor<Result> : IParseTreeVisitor<Result
+		>
 	{
 		/// <summary>
 		/// <inheritDoc></inheritDoc>
 		/// <p/>
 		/// The default implementation calls
-		/// <see cref="ParseTree.Accept{T}(ParseTreeVisitor{Result})">ParseTree.Accept&lt;T&gt;(ParseTreeVisitor&lt;Result&gt;)
+		/// <see cref="IParseTree.Accept{T}(IParseTreeVisitor{Result})">IParseTree.Accept&lt;T&gt;(IParseTreeVisitor&lt;Result&gt;)
 		/// 	</see>
 		/// on the
 		/// specified tree.
 		/// </summary>
-		public virtual Result Visit(ParseTree tree)
+		public virtual Result Visit(IParseTree tree)
 		{
 			return tree.Accept(this);
 		}
@@ -55,7 +56,7 @@ namespace Antlr4.Runtime.Tree
 		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult()</see>
 		/// . Before visiting each child, it
 		/// calls
-		/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(RuleNode, object)
+		/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, object)
 		/// 	">shouldVisitNextChild</see>
 		/// ; if the result
 		/// is
@@ -68,7 +69,7 @@ namespace Antlr4.Runtime.Tree
 		/// with the
 		/// previous aggregate result and the result of visiting the child.
 		/// </summary>
-		public virtual Result VisitChildren(RuleNode node)
+		public virtual Result VisitChildren(IRuleNode node)
 		{
 			Result result = DefaultResult();
 			int n = node.GetChildCount();
@@ -78,7 +79,7 @@ namespace Antlr4.Runtime.Tree
 				{
 					break;
 				}
-				ParseTree c = node.GetChild(i);
+				IParseTree c = node.GetChild(i);
 				Result childResult = c.Accept(this);
 				result = AggregateResult(result, childResult);
 			}
@@ -92,7 +93,7 @@ namespace Antlr4.Runtime.Tree
 		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
 		/// .
 		/// </summary>
-		public virtual Result VisitTerminal(TerminalNode node)
+		public virtual Result VisitTerminal(ITerminalNode node)
 		{
 			return DefaultResult();
 		}
@@ -104,7 +105,7 @@ namespace Antlr4.Runtime.Tree
 		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
 		/// .
 		/// </summary>
-		public virtual Result VisitErrorNode(ErrorNode node)
+		public virtual Result VisitErrorNode(IErrorNode node)
 		{
 			return DefaultResult();
 		}
@@ -113,14 +114,14 @@ namespace Antlr4.Runtime.Tree
 		/// <remarks>
 		/// Gets the default value returned by visitor methods. This value is
 		/// returned by the default implementations of
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitTerminal(TerminalNode)">visitTerminal
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitTerminal(ITerminalNode)">visitTerminal
 		/// 	</see>
 		/// ,
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitErrorNode(ErrorNode)">visitErrorNode
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitErrorNode(IErrorNode)">visitErrorNode
 		/// 	</see>
 		/// .
 		/// The default implementation of
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">visitChildren
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">visitChildren
 		/// 	</see>
 		/// initializes its aggregate result to this value.
 		/// <p/>
@@ -138,19 +139,20 @@ namespace Antlr4.Runtime.Tree
 		/// <remarks>
 		/// Aggregates the results of visiting multiple children of a node. After
 		/// either all children are visited or
-		/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(RuleNode, object)
-		/// 	">AbstractParseTreeVisitor&lt;Result&gt;.ShouldVisitNextChild(RuleNode, object)</see>
+		/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, object)
+		/// 	">AbstractParseTreeVisitor&lt;Result&gt;.ShouldVisitNextChild(IRuleNode, object)
+		/// 	</see>
 		/// returns
 		/// <code>false</code>
 		/// , the aggregate value is returned as the result of
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
 		/// 	</see>
 		/// .
 		/// <p/>
 		/// The default implementation returns
 		/// <code>nextResult</code>
 		/// , meaning
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
 		/// 	</see>
 		/// will return the result of the last child visited
 		/// (or return the initial value if the node has no children).
@@ -178,7 +180,7 @@ namespace Antlr4.Runtime.Tree
 
 		/// <summary>
 		/// This method is called after visiting each child in
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
 		/// 	</see>
 		/// . This method is first called before the first
 		/// child is visited; at that point
@@ -203,7 +205,7 @@ namespace Antlr4.Runtime.Tree
 		/// </summary>
 		/// <param name="node">
 		/// The
-		/// <see cref="RuleNode">RuleNode</see>
+		/// <see cref="IRuleNode">IRuleNode</see>
 		/// whose children are currently being
 		/// visited.
 		/// </param>
@@ -218,11 +220,11 @@ namespace Antlr4.Runtime.Tree
 		/// <code>false</code>
 		/// to stop visiting children and immediately return the
 		/// current aggregate result from
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(RuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(RuleNode)
+		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
 		/// 	</see>
 		/// .
 		/// </returns>
-		protected internal virtual bool ShouldVisitNextChild(RuleNode node, Result currentResult
+		protected internal virtual bool ShouldVisitNextChild(IRuleNode node, Result currentResult
 			)
 		{
 			return true;
diff --git a/Antlr4.Runtime/Tree/ErrorNode.cs b/Antlr4.Runtime/Tree/ErrorNode.cs
index a6ad6be06..fc23ca59e 100644
--- a/Antlr4.Runtime/Tree/ErrorNode.cs
+++ b/Antlr4.Runtime/Tree/ErrorNode.cs
@@ -27,12 +27,11 @@
  *  (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.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface ErrorNode : TerminalNode
+	public interface ErrorNode : ITerminalNode
 	{
 	}
 }
diff --git a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
index 28e805138..311c36af7 100644
--- a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
@@ -44,13 +44,13 @@ namespace Antlr4.Runtime.Tree
 	/// and deletion as well as during "consume until error recovery set"
 	/// upon no viable alternative exceptions.
 	/// </remarks>
-	public class ErrorNodeImpl : TerminalNodeImpl, ErrorNode
+	public class ErrorNodeImpl : TerminalNodeImpl, IErrorNode
 	{
 		public ErrorNodeImpl(Token token) : base(token)
 		{
 		}
 
-		public override T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor)
+		public override T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor)
 		{
 			return visitor.VisitErrorNode(this);
 		}
diff --git a/Antlr4.Runtime/Tree/ParseTree.cs b/Antlr4.Runtime/Tree/ParseTree.cs
index 4b9bb07a7..1123ebaf8 100644
--- a/Antlr4.Runtime/Tree/ParseTree.cs
+++ b/Antlr4.Runtime/Tree/ParseTree.cs
@@ -28,7 +28,6 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -47,19 +46,19 @@ namespace Antlr4.Runtime.Tree
 	/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
 	/// object.
 	/// </summary>
-	public interface ParseTree : SyntaxTree
+	public interface ParseTree : ISyntaxTree
 	{
 		// the following methods narrow the return type; they are not additional methods
-		ParseTree GetParent();
+		IParseTree GetParent();
 
-		ParseTree GetChild(int i);
+		IParseTree GetChild(int i);
 
 		/// <summary>
 		/// The
 		/// <see cref="ParseTreeVisitor{Result}">ParseTreeVisitor&lt;Result&gt;</see>
 		/// needs a double dispatch method.
 		/// </summary>
-		T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor) where _T1:T;
+		T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T;
 
 		/// <summary>Return the combined text of all leaf nodes.</summary>
 		/// <remarks>
diff --git a/Antlr4.Runtime/Tree/ParseTreeListener.cs b/Antlr4.Runtime/Tree/ParseTreeListener.cs
index a72b34b27..91d574914 100644
--- a/Antlr4.Runtime/Tree/ParseTreeListener.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeListener.cs
@@ -28,16 +28,15 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
 	public interface ParseTreeListener
 	{
-		void VisitTerminal(TerminalNode node);
+		void VisitTerminal(ITerminalNode node);
 
-		void VisitErrorNode(ErrorNode node);
+		void VisitErrorNode(IErrorNode node);
 
 		void EnterEveryRule(ParserRuleContext ctx);
 
diff --git a/Antlr4.Runtime/Tree/ParseTreeProperty.cs b/Antlr4.Runtime/Tree/ParseTreeProperty.cs
index 02058e231..a1f9fd41b 100644
--- a/Antlr4.Runtime/Tree/ParseTreeProperty.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeProperty.cs
@@ -50,20 +50,20 @@ namespace Antlr4.Runtime.Tree
 	/// </remarks>
 	public class ParseTreeProperty<V>
 	{
-		protected internal IDictionary<ParseTree, V> annotations = new IdentityHashMap<ParseTree
+		protected internal IDictionary<IParseTree, V> annotations = new IdentityHashMap<IParseTree
 			, V>();
 
-		public virtual V Get(ParseTree node)
+		public virtual V Get(IParseTree node)
 		{
 			return annotations.Get(node);
 		}
 
-		public virtual void Put(ParseTree node, V value)
+		public virtual void Put(IParseTree node, V value)
 		{
 			annotations.Put(node, value);
 		}
 
-		public virtual V RemoveFrom(ParseTree node)
+		public virtual V RemoveFrom(IParseTree node)
 		{
 			return Sharpen.Collections.Remove(annotations, node);
 		}
diff --git a/Antlr4.Runtime/Tree/ParseTreeVisitor.cs b/Antlr4.Runtime/Tree/ParseTreeVisitor.cs
index a968a9aef..42410bc9e 100644
--- a/Antlr4.Runtime/Tree/ParseTreeVisitor.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeVisitor.cs
@@ -27,7 +27,6 @@
  *  (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.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -50,11 +49,11 @@ namespace Antlr4.Runtime.Tree
 		/// <remarks>Visit a parse tree, and return a user-defined result of the operation.</remarks>
 		/// <param name="tree">
 		/// The
-		/// <see cref="ParseTree">ParseTree</see>
+		/// <see cref="IParseTree">IParseTree</see>
 		/// to visit.
 		/// </param>
 		/// <returns>The result of visiting the parse tree.</returns>
-		Result Visit(ParseTree tree);
+		Result Visit(IParseTree tree);
 
 		/// <summary>
 		/// Visit the children of a node, and return a user-defined result
@@ -66,11 +65,11 @@ namespace Antlr4.Runtime.Tree
 		/// </remarks>
 		/// <param name="node">
 		/// The
-		/// <see cref="RuleNode">RuleNode</see>
+		/// <see cref="IRuleNode">IRuleNode</see>
 		/// whose children should be visited.
 		/// </param>
 		/// <returns>The result of visiting the children of the node.</returns>
-		Result VisitChildren(RuleNode node);
+		Result VisitChildren(IRuleNode node);
 
 		/// <summary>Visit a terminal node, and return a user-defined result of the operation.
 		/// 	</summary>
@@ -78,20 +77,20 @@ namespace Antlr4.Runtime.Tree
 		/// 	</remarks>
 		/// <param name="node">
 		/// The
-		/// <see cref="TerminalNode">TerminalNode</see>
+		/// <see cref="ITerminalNode">ITerminalNode</see>
 		/// to visit.
 		/// </param>
 		/// <returns>The result of visiting the node.</returns>
-		Result VisitTerminal(TerminalNode node);
+		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="ErrorNode">ErrorNode</see>
+		/// <see cref="IErrorNode">IErrorNode</see>
 		/// to visit.
 		/// </param>
 		/// <returns>The result of visiting the node.</returns>
-		Result VisitErrorNode(ErrorNode node);
+		Result VisitErrorNode(IErrorNode node);
 	}
 }
diff --git a/Antlr4.Runtime/Tree/ParseTreeWalker.cs b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
index e288c2e49..c2f3e42dc 100644
--- a/Antlr4.Runtime/Tree/ParseTreeWalker.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
@@ -37,22 +37,22 @@ namespace Antlr4.Runtime.Tree
 	{
 		public static readonly ParseTreeWalker Default = new ParseTreeWalker();
 
-		public virtual void Walk(ParseTreeListener listener, ParseTree t)
+		public virtual void Walk(IParseTreeListener listener, IParseTree t)
 		{
-			if (t is ErrorNode)
+			if (t is IErrorNode)
 			{
-				listener.VisitErrorNode((ErrorNode)t);
+				listener.VisitErrorNode((IErrorNode)t);
 				return;
 			}
 			else
 			{
-				if (t is TerminalNode)
+				if (t is ITerminalNode)
 				{
-					listener.VisitTerminal((TerminalNode)t);
+					listener.VisitTerminal((ITerminalNode)t);
 					return;
 				}
 			}
-			RuleNode r = (RuleNode)t;
+			IRuleNode r = (IRuleNode)t;
 			EnterRule(listener, r);
 			int n = r.GetChildCount();
 			for (int i = 0; i < n; i++)
@@ -64,21 +64,23 @@ namespace Antlr4.Runtime.Tree
 
 		/// <summary>
 		/// The discovery of a rule node, involves sending two events: the generic
-		/// <see cref="ParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)">ParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)
+		/// <see cref="IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)">IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)
 		/// 	</see>
 		/// and a
 		/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
 		/// -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(ParseTreeListener listener, RuleNode r)
+		protected internal virtual void EnterRule(IParseTreeListener listener, IRuleNode 
+			r)
 		{
 			ParserRuleContext ctx = (ParserRuleContext)r.GetRuleContext();
 			listener.EnterEveryRule(ctx);
 			ctx.EnterRule(listener);
 		}
 
-		protected internal virtual void ExitRule(ParseTreeListener listener, RuleNode r)
+		protected internal virtual void ExitRule(IParseTreeListener listener, IRuleNode r
+			)
 		{
 			ParserRuleContext ctx = (ParserRuleContext)r.GetRuleContext();
 			ctx.ExitRule(listener);
diff --git a/Antlr4.Runtime/Tree/RuleNode.cs b/Antlr4.Runtime/Tree/RuleNode.cs
index a741ca014..6c4dfafd7 100644
--- a/Antlr4.Runtime/Tree/RuleNode.cs
+++ b/Antlr4.Runtime/Tree/RuleNode.cs
@@ -28,15 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface RuleNode : ParseTree
+	public interface RuleNode : IParseTree
 	{
 		RuleContext GetRuleContext();
 
-		RuleNode GetParent();
+		IRuleNode GetParent();
 	}
 }
diff --git a/Antlr4.Runtime/Tree/SyntaxTree.cs b/Antlr4.Runtime/Tree/SyntaxTree.cs
index 0a40dae8c..c815b6e4c 100644
--- a/Antlr4.Runtime/Tree/SyntaxTree.cs
+++ b/Antlr4.Runtime/Tree/SyntaxTree.cs
@@ -28,7 +28,6 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Misc;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -42,13 +41,13 @@ namespace Antlr4.Runtime.Tree
 	/// 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 SyntaxTree : Antlr4.Runtime.Tree.Tree
+	public interface SyntaxTree : ITree
 	{
 		/// <summary>
 		/// Return an
 		/// <see cref="Antlr4.Runtime.Misc.Interval">Antlr4.Runtime.Misc.Interval</see>
 		/// indicating the index in the
-		/// <see cref="Antlr4.Runtime.TokenStream">Antlr4.Runtime.TokenStream</see>
+		/// <see cref="ITokenStream">ITokenStream</see>
 		/// of the first and last token associated with this
 		/// subtree. If this node is a leaf, then the interval represents a single
 		/// token.
diff --git a/Antlr4.Runtime/Tree/TerminalNode.cs b/Antlr4.Runtime/Tree/TerminalNode.cs
index b1c9c08be..ff0103340 100644
--- a/Antlr4.Runtime/Tree/TerminalNode.cs
+++ b/Antlr4.Runtime/Tree/TerminalNode.cs
@@ -28,15 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface TerminalNode : ParseTree
+	public interface TerminalNode : IParseTree
 	{
 		Token GetSymbol();
 
-		RuleNode GetParent();
+		IRuleNode GetParent();
 	}
 }
diff --git a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
index 3d7ca4636..7fcfb1f07 100644
--- a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
@@ -29,23 +29,22 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public class TerminalNodeImpl : TerminalNode
+	public class TerminalNodeImpl : ITerminalNode
 	{
 		public Token symbol;
 
-		public RuleNode parent;
+		public IRuleNode parent;
 
 		public TerminalNodeImpl(Token symbol)
 		{
 			this.symbol = symbol;
 		}
 
-		public virtual ParseTree GetChild(int i)
+		public virtual IParseTree GetChild(int i)
 		{
 			return null;
 		}
@@ -55,7 +54,7 @@ namespace Antlr4.Runtime.Tree
 			return symbol;
 		}
 
-		public virtual RuleNode GetParent()
+		public virtual IRuleNode GetParent()
 		{
 			return parent;
 		}
@@ -80,7 +79,7 @@ namespace Antlr4.Runtime.Tree
 			return 0;
 		}
 
-		public virtual T Accept<T, _T1>(ParseTreeVisitor<_T1> visitor) where _T1:T
+		public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
 		{
 			return visitor.VisitTerminal(this);
 		}
diff --git a/Antlr4.Runtime/Tree/Tree.cs b/Antlr4.Runtime/Tree/Tree.cs
index 9256db8c6..3e6ce5a40 100644
--- a/Antlr4.Runtime/Tree/Tree.cs
+++ b/Antlr4.Runtime/Tree/Tree.cs
@@ -44,7 +44,7 @@ namespace Antlr4.Runtime.Tree
 		/// The parent of this node. If the return value is null, then this
 		/// node is the root of the tree.
 		/// </remarks>
-		Antlr4.Runtime.Tree.Tree GetParent();
+		ITree GetParent();
 
 		/// <summary>This method returns whatever object represents the data at this note.</summary>
 		/// <remarks>
@@ -66,7 +66,7 @@ namespace Antlr4.Runtime.Tree
 		/// <code>i</code>
 		/// th value indexed from 0.
 		/// </summary>
-		Antlr4.Runtime.Tree.Tree GetChild(int i);
+		ITree GetChild(int i);
 
 		/// <summary>
 		/// How many children are there? If there is none, then this
diff --git a/Antlr4.Runtime/Tree/Trees.cs b/Antlr4.Runtime/Tree/Trees.cs
index 502bd5ec6..0002b6e24 100644
--- a/Antlr4.Runtime/Tree/Trees.cs
+++ b/Antlr4.Runtime/Tree/Trees.cs
@@ -32,7 +32,6 @@ using System.IO;
 using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
-using Antlr4.Runtime.Tree;
 using Antlr4.Runtime.Tree.Gui;
 using Sharpen;
 
@@ -42,22 +41,22 @@ namespace Antlr4.Runtime.Tree
 	/// <remarks>A set of utility routines useful for all kinds of ANTLR trees.</remarks>
 	public class Trees
 	{
-		public static string GetPS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames, string
-			 fontName, int fontSize)
+		public static string GetPS(ITree t, IList<string> ruleNames, string fontName, int
+			 fontSize)
 		{
 			TreePostScriptGenerator psgen = new TreePostScriptGenerator(ruleNames, t, fontName
 				, fontSize);
 			return psgen.GetPS();
 		}
 
-		public static string GetPS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames)
+		public static string GetPS(ITree t, IList<string> ruleNames)
 		{
 			return GetPS(t, ruleNames, "Helvetica", 11);
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public static void WritePS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames, string
-			 fileName, string fontName, int fontSize)
+		public static void WritePS(ITree t, IList<string> ruleNames, string fileName, string
+			 fontName, int fontSize)
 		{
 			string ps = GetPS(t, ruleNames, fontName, fontSize);
 			FileWriter f = new FileWriter(fileName);
@@ -67,8 +66,7 @@ namespace Antlr4.Runtime.Tree
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public static void WritePS(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames, string
-			 fileName)
+		public static void WritePS(ITree t, IList<string> ruleNames, string fileName)
 		{
 			WritePS(t, ruleNames, fileName, "Helvetica", 11);
 		}
@@ -76,13 +74,13 @@ namespace Antlr4.Runtime.Tree
 		/// <summary>Print out a whole tree in LISP form.</summary>
 		/// <remarks>
 		/// Print out a whole tree in LISP form.
-		/// <see cref="GetNodeText(Tree, Antlr4.Runtime.Parser)">GetNodeText(Tree, Antlr4.Runtime.Parser)
+		/// <see cref="GetNodeText(ITree, Antlr4.Runtime.Parser)">GetNodeText(ITree, Antlr4.Runtime.Parser)
 		/// 	</see>
 		/// 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(Antlr4.Runtime.Tree.Tree t)
+		public static string ToStringTree(ITree t)
 		{
 			return ToStringTree(t, (IList<string>)null);
 		}
@@ -90,13 +88,13 @@ namespace Antlr4.Runtime.Tree
 		/// <summary>Print out a whole tree in LISP form.</summary>
 		/// <remarks>
 		/// Print out a whole tree in LISP form.
-		/// <see cref="GetNodeText(Tree, Antlr4.Runtime.Parser)">GetNodeText(Tree, Antlr4.Runtime.Parser)
+		/// <see cref="GetNodeText(ITree, Antlr4.Runtime.Parser)">GetNodeText(ITree, Antlr4.Runtime.Parser)
 		/// 	</see>
 		/// 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(Antlr4.Runtime.Tree.Tree t, Parser recog)
+		public static string ToStringTree(ITree t, Parser recog)
 		{
 			string[] ruleNames = recog != null ? recog.GetRuleNames() : null;
 			IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
@@ -106,14 +104,13 @@ namespace Antlr4.Runtime.Tree
 		/// <summary>Print out a whole tree in LISP form.</summary>
 		/// <remarks>
 		/// Print out a whole tree in LISP form.
-		/// <see cref="GetNodeText(Tree, Antlr4.Runtime.Parser)">GetNodeText(Tree, Antlr4.Runtime.Parser)
+		/// <see cref="GetNodeText(ITree, Antlr4.Runtime.Parser)">GetNodeText(ITree, Antlr4.Runtime.Parser)
 		/// 	</see>
 		/// 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(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames
-			)
+		public static string ToStringTree(ITree t, IList<string> ruleNames)
 		{
 			string s = Utils.EscapeWhitespace(GetNodeText(t, ruleNames), false);
 			if (t.GetChildCount() == 0)
@@ -137,35 +134,34 @@ namespace Antlr4.Runtime.Tree
 			return buf.ToString();
 		}
 
-		public static string GetNodeText(Antlr4.Runtime.Tree.Tree t, Parser recog)
+		public static string GetNodeText(ITree t, Parser recog)
 		{
 			string[] ruleNames = recog != null ? recog.GetRuleNames() : null;
 			IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
 			return GetNodeText(t, ruleNamesList);
 		}
 
-		public static string GetNodeText(Antlr4.Runtime.Tree.Tree t, IList<string> ruleNames
-			)
+		public static string GetNodeText(ITree t, IList<string> ruleNames)
 		{
 			if (ruleNames != null)
 			{
-				if (t is RuleNode)
+				if (t is IRuleNode)
 				{
-					int ruleIndex = ((RuleNode)t).GetRuleContext().GetRuleIndex();
+					int ruleIndex = ((IRuleNode)t).GetRuleContext().GetRuleIndex();
 					string ruleName = ruleNames[ruleIndex];
 					return ruleName;
 				}
 				else
 				{
-					if (t is ErrorNode)
+					if (t is IErrorNode)
 					{
 						return t.ToString();
 					}
 					else
 					{
-						if (t is TerminalNode)
+						if (t is ITerminalNode)
 						{
-							object symbol = ((TerminalNode)t).GetSymbol();
+							object symbol = ((ITerminalNode)t).GetSymbol();
 							if (symbol is Token)
 							{
 								string s = ((Token)symbol).GetText();
@@ -190,14 +186,13 @@ namespace Antlr4.Runtime.Tree
 		/// list is the root and the last is the parent of this node.
 		/// </remarks>
 		[NotNull]
-		public static IList<Antlr4.Runtime.Tree.Tree> GetAncestors(Antlr4.Runtime.Tree.Tree
-			 t)
+		public static IList<ITree> GetAncestors(ITree t)
 		{
 			if (t.GetParent() == null)
 			{
 				return Sharpen.Collections.EmptyList();
 			}
-			IList<Antlr4.Runtime.Tree.Tree> ancestors = new AList<Antlr4.Runtime.Tree.Tree>();
+			IList<ITree> ancestors = new AList<ITree>();
 			t = t.GetParent();
 			while (t != null)
 			{
diff --git a/Antlr4.Runtime/UnbufferedTokenStream.cs b/Antlr4.Runtime/UnbufferedTokenStream.cs
index a78c21262..3892fa3e5 100644
--- a/Antlr4.Runtime/UnbufferedTokenStream.cs
+++ b/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -35,9 +35,9 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public class UnbufferedTokenStream : TokenStream
+	public class UnbufferedTokenStream : ITokenStream
 	{
-		protected internal TokenSource tokenSource;
+		protected internal ITokenSource tokenSource;
 
 		/// <summary>A moving window buffer of the data being scanned.</summary>
 		/// <remarks>
@@ -123,16 +123,16 @@ namespace Antlr4.Runtime
 		/// <p/>
 		/// This value is used to set the token indexes if the stream provides tokens
 		/// that implement
-		/// <see cref="WritableToken">WritableToken</see>
+		/// <see cref="IWritableToken">IWritableToken</see>
 		/// .
 		/// </remarks>
 		protected internal int currentTokenIndex = 0;
 
-		public UnbufferedTokenStream(TokenSource tokenSource) : this(tokenSource, 256)
+		public UnbufferedTokenStream(ITokenSource tokenSource) : this(tokenSource, 256)
 		{
 		}
 
-		public UnbufferedTokenStream(TokenSource tokenSource, int bufferSize)
+		public UnbufferedTokenStream(ITokenSource tokenSource, int bufferSize)
 		{
 			this.tokenSource = tokenSource;
 			Token[] tokens = new Token[bufferSize];
@@ -178,7 +178,7 @@ namespace Antlr4.Runtime
 			return Lt(i).GetType();
 		}
 
-		public virtual TokenSource GetTokenSource()
+		public virtual ITokenSource GetTokenSource()
 		{
 			return tokenSource;
 		}
@@ -285,9 +285,9 @@ namespace Antlr4.Runtime
 			{
 				tokens = Arrays.CopyOf(tokens, tokens.Length * 2);
 			}
-			if (t is WritableToken)
+			if (t is IWritableToken)
 			{
-				((WritableToken)t).SetTokenIndex(GetBufferStartIndex() + n);
+				((IWritableToken)t).SetTokenIndex(GetBufferStartIndex() + n);
 			}
 			tokens[n++] = t;
 		}
diff --git a/reference/sharpen-all-options.txt b/reference/sharpen-all-options.txt
index 15a4f44fc..e87226813 100644
--- a/reference/sharpen-all-options.txt
+++ b/reference/sharpen-all-options.txt
@@ -183,3 +183,23 @@
 -typeMapping org.antlr.v4.runtime.misc.Tuple2<,> System.Tuple
 -typeMapping org.antlr.v4.runtime.misc.Tuple3<,,> System.Tuple
 
+-typeMapping org.antlr.v4.runtime.ANTLRErrorListener<> IAntlrErrorListener
+-typeMapping org.antlr.v4.runtime.ANTLRErrorStrategy IAntlrErrorStrategy
+-typeMapping org.antlr.v4.runtime.ParserErrorListener IParserErrorListener
+-typeMapping org.antlr.v4.runtime.TokenFactory ITokenFactory
+-typeMapping org.antlr.v4.runtime.TokenSource ITokenSource
+-typeMapping org.antlr.v4.runtime.TokenStream ITokenStream
+-typeMapping org.antlr.v4.runtime.WritableToken IWritableToken
+
+-typeMapping org.antlr.v4.runtime.dfa.EdgeMap<> IEdgeMap
+
+-typeMapping org.antlr.v4.runtime.misc.IntSet IIntSet
+
+-typeMapping org.antlr.v4.runtime.tree.ErrorNode IErrorNode
+-typeMapping org.antlr.v4.runtime.tree.ParseTree IParseTree
+-typeMapping org.antlr.v4.runtime.tree.ParseTreeListener IParseTreeListener
+-typeMapping org.antlr.v4.runtime.tree.ParseTreeVisitor<> IParseTreeVisitor
+-typeMapping org.antlr.v4.runtime.tree.RuleNode IRuleNode
+-typeMapping org.antlr.v4.runtime.tree.SyntaxTree ISyntaxTree
+-typeMapping org.antlr.v4.runtime.tree.TerminalNode ITerminalNode
+-typeMapping org.antlr.v4.runtime.tree.Tree ITree

From 6674e9c4c71993eb193bf6a1802b294b329fd36d Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Fri, 15 Feb 2013 16:30:46 -0600
Subject: [PATCH 04/10] Native interface names; generic type parameter count in
 file names

---
 Antlr4.Runtime/ANTLRFileStream.cs             |   7 +-
 Antlr4.Runtime/ANTLRInputStream.cs            |  26 +--
 Antlr4.Runtime/Antlr4.Runtime.csproj          |  78 ++++----
 Antlr4.Runtime/Atn/ATN.cs                     |  10 +-
 Antlr4.Runtime/Atn/ATNConfig.cs               |   6 +-
 Antlr4.Runtime/Atn/ATNConfigSet.cs            |  18 +-
 Antlr4.Runtime/Atn/ATNSimulator.cs            |  14 +-
 Antlr4.Runtime/Atn/ATNState.cs                |   4 +-
 Antlr4.Runtime/Atn/ArrayPredictionContext.cs  |   4 +-
 Antlr4.Runtime/Atn/LL1Analyzer.cs             |  14 +-
 Antlr4.Runtime/Atn/LexerATNSimulator.cs       |  44 ++---
 Antlr4.Runtime/Atn/ParserATNSimulator.cs      |  21 ++-
 Antlr4.Runtime/Atn/PredictionContext.cs       |   4 +-
 Antlr4.Runtime/Atn/SemanticContext.cs         |   6 +-
 Antlr4.Runtime/Atn/SetTransition.cs           |   2 +-
 Antlr4.Runtime/BailErrorStrategy.cs           |   2 +-
 Antlr4.Runtime/BaseErrorListener.cs           |   2 +-
 Antlr4.Runtime/BufferedTokenStream.cs         |  56 +++---
 Antlr4.Runtime/CommonToken.cs                 |  12 +-
 Antlr4.Runtime/CommonTokenStream.cs           |  10 +-
 Antlr4.Runtime/DefaultErrorStrategy.cs        |  46 ++---
 ...bstractEdgeMap.cs => AbstractEdgeMap`1.cs} |   0
 .../{ArrayEdgeMap.cs => ArrayEdgeMap`1.cs}    |   0
 Antlr4.Runtime/Dfa/DFA.cs                     |  10 +-
 Antlr4.Runtime/Dfa/DFASerializer.cs           |   2 +-
 .../Dfa/{EdgeMap.cs => IEdgeMap`1.cs}         |   3 +-
 ...gletonEdgeMap.cs => SingletonEdgeMap`1.cs} |   0
 .../{SparseEdgeMap.cs => SparseEdgeMap`1.cs}  |   4 +-
 ...orListener.cs => IAntlrErrorListener`1.cs} |   2 +-
 ...rrorStrategy.cs => IAntlrErrorStrategy.cs} |   4 +-
 .../{CharStream.cs => ICharStream.cs}         |   6 +-
 .../{IntStream.cs => IIntStream.cs}           |   8 +-
 ...rorListener.cs => IParserErrorListener.cs} |   2 +-
 Antlr4.Runtime/{Token.cs => IToken.cs}        |   8 +-
 .../{TokenFactory.cs => ITokenFactory.cs}     |   6 +-
 .../{TokenSource.cs => ITokenSource.cs}       |   6 +-
 .../{TokenStream.cs => ITokenStream.cs}       |  28 +--
 .../{WritableToken.cs => IWritableToken.cs}   |   2 +-
 Antlr4.Runtime/Lexer.cs                       |  56 +++---
 Antlr4.Runtime/LexerNoViableAltException.cs   |  12 +-
 ...tor.cs => AbstractEqualityComparator`1.cs} |   2 +-
 ...{Array2DHashSet.cs => Array2DHashSet`1.cs} |   4 +-
 .../{DoubleKeyMap.cs => DoubleKeyMap`3.cs}    |   0
 ...lexibleHashMap.cs => FlexibleHashMap`2.cs} |   2 +-
 ...Comparator.cs => IEqualityComparator`1.cs} |   2 +-
 Antlr4.Runtime/Misc/{Func0.cs => IFunc0`1.cs} |   2 +-
 Antlr4.Runtime/Misc/{Func1.cs => IFunc1`2.cs} |   2 +-
 Antlr4.Runtime/Misc/{IntSet.cs => IIntSet.cs} |   3 +-
 .../Misc/{Predicate.cs => IPredicate`1.cs}    |   2 +-
 Antlr4.Runtime/Misc/IntervalSet.cs            |  20 +-
 .../Misc/{MultiMap.cs => MultiMap`2.cs}       |   4 +-
 .../Misc/ObjectEqualityComparator.cs          |   2 +-
 ...{OrderedHashSet.cs => OrderedHashSet`1.cs} |   4 +-
 Antlr4.Runtime/Misc/RuleDependencyChecker.cs  |  20 +-
 .../Misc/RuleDependencyProcessor.cs           | 176 +++++++++---------
 Antlr4.Runtime/Misc/TestRig.cs                |   8 +-
 Antlr4.Runtime/Misc/Tuple.cs                  |  55 +-----
 Antlr4.Runtime/Misc/Tuple`2.cs                |  84 +++++++++
 Antlr4.Runtime/Misc/Tuple`3.cs                |  93 +++++++++
 Antlr4.Runtime/Misc/Utils.cs                  |   4 +-
 Antlr4.Runtime/NoViableAltException.cs        |   8 +-
 Antlr4.Runtime/Parser.cs                      |  61 +++---
 Antlr4.Runtime/ParserRuleContext.cs           |  24 +--
 ...rorListener.cs => ProxyErrorListener`1.cs} |   0
 Antlr4.Runtime/ProxyParserErrorListener.cs    |  10 +-
 Antlr4.Runtime/RecognitionException.cs        |  18 +-
 .../{Recognizer.cs => Recognizer`2.cs}        |   8 +-
 Antlr4.Runtime/RuleContext.cs                 |   4 +-
 Antlr4.Runtime/TokenStreamRewriter.cs         |  34 ++--
 ...sitor.cs => AbstractParseTreeVisitor`1.cs} |   0
 Antlr4.Runtime/Tree/ErrorNodeImpl.cs          |   2 +-
 .../Tree/{ErrorNode.cs => IErrorNode.cs}      |   3 +-
 .../Tree/{ParseTree.cs => IParseTree.cs}      |   7 +-
 ...eTreeListener.cs => IParseTreeListener.cs} |   3 +-
 ...eTreeVisitor.cs => IParseTreeVisitor`1.cs} |   3 +-
 .../Tree/{RuleNode.cs => IRuleNode.cs}        |   3 +-
 .../Tree/{SyntaxTree.cs => ISyntaxTree.cs}    |   5 +-
 .../{TerminalNode.cs => ITerminalNode.cs}     |   5 +-
 Antlr4.Runtime/Tree/{Tree.cs => ITree.cs}     |   7 +-
 ...TreeProperty.cs => ParseTreeProperty`1.cs} |   0
 Antlr4.Runtime/Tree/TerminalNodeImpl.cs       |  11 +-
 Antlr4.Runtime/Tree/Trees.cs                  |  11 +-
 Antlr4.Runtime/UnbufferedCharStream.cs        |  12 +-
 Antlr4.Runtime/UnbufferedTokenStream.cs       |  26 +--
 reference/sharpen                             |   2 +-
 reference/sharpen-all-options.txt             |  23 +--
 86 files changed, 730 insertions(+), 594 deletions(-)
 rename Antlr4.Runtime/Dfa/{AbstractEdgeMap.cs => AbstractEdgeMap`1.cs} (100%)
 rename Antlr4.Runtime/Dfa/{ArrayEdgeMap.cs => ArrayEdgeMap`1.cs} (100%)
 rename Antlr4.Runtime/Dfa/{EdgeMap.cs => IEdgeMap`1.cs} (97%)
 rename Antlr4.Runtime/Dfa/{SingletonEdgeMap.cs => SingletonEdgeMap`1.cs} (100%)
 rename Antlr4.Runtime/Dfa/{SparseEdgeMap.cs => SparseEdgeMap`1.cs} (98%)
 rename Antlr4.Runtime/{ANTLRErrorListener.cs => IAntlrErrorListener`1.cs} (98%)
 rename Antlr4.Runtime/{ANTLRErrorStrategy.cs => IAntlrErrorStrategy.cs} (98%)
 rename Antlr4.Runtime/{CharStream.cs => ICharStream.cs} (96%)
 rename Antlr4.Runtime/{IntStream.cs => IIntStream.cs} (98%)
 rename Antlr4.Runtime/{ParserErrorListener.cs => IParserErrorListener.cs} (97%)
 rename Antlr4.Runtime/{Token.cs => IToken.cs} (96%)
 rename Antlr4.Runtime/{TokenFactory.cs => ITokenFactory.cs} (94%)
 rename Antlr4.Runtime/{TokenSource.cs => ITokenSource.cs} (98%)
 rename Antlr4.Runtime/{TokenStream.cs => ITokenStream.cs} (91%)
 rename Antlr4.Runtime/{WritableToken.cs => IWritableToken.cs} (97%)
 rename Antlr4.Runtime/Misc/{AbstractEqualityComparator.cs => AbstractEqualityComparator`1.cs} (96%)
 rename Antlr4.Runtime/Misc/{Array2DHashSet.cs => Array2DHashSet`1.cs} (99%)
 rename Antlr4.Runtime/Misc/{DoubleKeyMap.cs => DoubleKeyMap`3.cs} (100%)
 rename Antlr4.Runtime/Misc/{FlexibleHashMap.cs => FlexibleHashMap`2.cs} (99%)
 rename Antlr4.Runtime/Misc/{EqualityComparator.cs => IEqualityComparator`1.cs} (98%)
 rename Antlr4.Runtime/Misc/{Func0.cs => IFunc0`1.cs} (98%)
 rename Antlr4.Runtime/Misc/{Func1.cs => IFunc1`2.cs} (97%)
 rename Antlr4.Runtime/Misc/{IntSet.cs => IIntSet.cs} (98%)
 rename Antlr4.Runtime/Misc/{Predicate.cs => IPredicate`1.cs} (98%)
 rename Antlr4.Runtime/Misc/{MultiMap.cs => MultiMap`2.cs} (95%)
 rename Antlr4.Runtime/Misc/{OrderedHashSet.cs => OrderedHashSet`1.cs} (97%)
 create mode 100644 Antlr4.Runtime/Misc/Tuple`2.cs
 create mode 100644 Antlr4.Runtime/Misc/Tuple`3.cs
 rename Antlr4.Runtime/{ProxyErrorListener.cs => ProxyErrorListener`1.cs} (100%)
 rename Antlr4.Runtime/{Recognizer.cs => Recognizer`2.cs} (97%)
 rename Antlr4.Runtime/Tree/{AbstractParseTreeVisitor.cs => AbstractParseTreeVisitor`1.cs} (100%)
 rename Antlr4.Runtime/Tree/{ErrorNode.cs => IErrorNode.cs} (95%)
 rename Antlr4.Runtime/Tree/{ParseTree.cs => IParseTree.cs} (93%)
 rename Antlr4.Runtime/Tree/{ParseTreeListener.cs => IParseTreeListener.cs} (96%)
 rename Antlr4.Runtime/Tree/{ParseTreeVisitor.cs => IParseTreeVisitor`1.cs} (98%)
 rename Antlr4.Runtime/Tree/{RuleNode.cs => IRuleNode.cs} (96%)
 rename Antlr4.Runtime/Tree/{SyntaxTree.cs => ISyntaxTree.cs} (94%)
 rename Antlr4.Runtime/Tree/{TerminalNode.cs => ITerminalNode.cs} (94%)
 rename Antlr4.Runtime/Tree/{Tree.cs => ITree.cs} (94%)
 rename Antlr4.Runtime/Tree/{ParseTreeProperty.cs => ParseTreeProperty`1.cs} (100%)

diff --git a/Antlr4.Runtime/ANTLRFileStream.cs b/Antlr4.Runtime/ANTLRFileStream.cs
index 1fab3edaa..857b764f6 100644
--- a/Antlr4.Runtime/ANTLRFileStream.cs
+++ b/Antlr4.Runtime/ANTLRFileStream.cs
@@ -28,7 +28,6 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System.IO;
-using Antlr4.Runtime;
 using Sharpen;
 
 namespace Antlr4.Runtime
@@ -43,17 +42,17 @@ namespace Antlr4.Runtime
 	/// since we know the exact size of the object to load.  We can avoid lots
 	/// of data copying.
 	/// </remarks>
-	public class ANTLRFileStream : ANTLRInputStream
+	public class AntlrFileStream : AntlrInputStream
 	{
 		protected internal string fileName;
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRFileStream(string fileName) : this(fileName, null)
+		public AntlrFileStream(string fileName) : this(fileName, null)
 		{
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRFileStream(string fileName, string encoding)
+		public AntlrFileStream(string fileName, string encoding)
 		{
 			this.fileName = fileName;
 			Load(fileName, encoding);
diff --git a/Antlr4.Runtime/ANTLRInputStream.cs b/Antlr4.Runtime/ANTLRInputStream.cs
index 4f614b9af..0bcc8377f 100644
--- a/Antlr4.Runtime/ANTLRInputStream.cs
+++ b/Antlr4.Runtime/ANTLRInputStream.cs
@@ -42,7 +42,7 @@ namespace Antlr4.Runtime
 	/// Can also pass in a string or char[] to use.
 	/// If you need encoding, pass in stream/reader with correct encoding.
 	/// </remarks>
-	public class ANTLRInputStream : CharStream
+	public class AntlrInputStream : ICharStream
 	{
 		public const int ReadBufferSize = 1024;
 
@@ -60,56 +60,56 @@ namespace Antlr4.Runtime
 		/// <summary>What is name or source of this char stream?</summary>
 		public string name;
 
-		public ANTLRInputStream()
+		public AntlrInputStream()
 		{
 		}
 
 		/// <summary>Copy data in string to a local char array</summary>
-		public ANTLRInputStream(string input)
+		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)
+		public AntlrInputStream(char[] data, int numberOfActualCharsInArray)
 		{
 			this.data = data;
 			this.n = numberOfActualCharsInArray;
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRInputStream(StreamReader r) : this(r, InitialBufferSize, ReadBufferSize
+		public AntlrInputStream(StreamReader r) : this(r, InitialBufferSize, ReadBufferSize
 			)
 		{
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRInputStream(StreamReader r, int initialSize) : this(r, initialSize, ReadBufferSize
+		public AntlrInputStream(StreamReader r, int initialSize) : this(r, initialSize, ReadBufferSize
 			)
 		{
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRInputStream(StreamReader r, int initialSize, int readChunkSize)
+		public AntlrInputStream(StreamReader r, int initialSize, int readChunkSize)
 		{
 			Load(r, initialSize, readChunkSize);
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRInputStream(InputStream input) : this(new InputStreamReader(input), InitialBufferSize
+		public AntlrInputStream(InputStream input) : this(new InputStreamReader(input), InitialBufferSize
 			)
 		{
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRInputStream(InputStream input, int initialSize) : this(new InputStreamReader
+		public AntlrInputStream(InputStream input, int initialSize) : this(new InputStreamReader
 			(input), initialSize)
 		{
 		}
 
 		/// <exception cref="System.IO.IOException"></exception>
-		public ANTLRInputStream(InputStream input, int initialSize, int readChunkSize) : 
+		public AntlrInputStream(InputStream input, int initialSize, int readChunkSize) : 
 			this(new InputStreamReader(input), initialSize, readChunkSize)
 		{
 		}
@@ -181,7 +181,7 @@ namespace Antlr4.Runtime
 		{
 			if (p >= n)
 			{
-				System.Diagnostics.Debug.Assert(La(1) == IntStream.Eof);
+				System.Diagnostics.Debug.Assert(La(1) == IIntStream.Eof);
 				throw new InvalidOperationException("cannot consume EOF");
 			}
 			//System.out.println("prev p="+p+", c="+(char)data[p]);
@@ -205,14 +205,14 @@ namespace Antlr4.Runtime
 				// e.g., translate LA(-1) to use offset i=0; then data[p+0-1]
 				if ((p + i - 1) < 0)
 				{
-					return IntStream.Eof;
+					return IIntStream.Eof;
 				}
 			}
 			// invalid; no char before first char
 			if ((p + i - 1) >= n)
 			{
 				//System.out.println("char LA("+i+")=EOF; p="+p);
-				return IntStream.Eof;
+				return IIntStream.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);
diff --git a/Antlr4.Runtime/Antlr4.Runtime.csproj b/Antlr4.Runtime/Antlr4.Runtime.csproj
index b66dd38c9..861c74ab2 100644
--- a/Antlr4.Runtime/Antlr4.Runtime.csproj
+++ b/Antlr4.Runtime/Antlr4.Runtime.csproj
@@ -39,8 +39,6 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ANTLRErrorListener.cs" />
-    <Compile Include="ANTLRErrorStrategy.cs" />
     <Compile Include="ANTLRFileStream.cs" />
     <Compile Include="ANTLRInputStream.cs" />
     <Compile Include="Atn\AbstractPredicateTransition.cs" />
@@ -89,83 +87,87 @@
     <Compile Include="BailErrorStrategy.cs" />
     <Compile Include="BaseErrorListener.cs" />
     <Compile Include="BufferedTokenStream.cs" />
-    <Compile Include="CharStream.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\AbstractEdgeMap.cs" />
-    <Compile Include="Dfa\ArrayEdgeMap.cs" />
+    <Compile Include="Dfa\AbstractEdgeMap`1.cs" />
+    <Compile Include="Dfa\ArrayEdgeMap`1.cs" />
     <Compile Include="Dfa\DFA.cs" />
     <Compile Include="Dfa\DFASerializer.cs" />
     <Compile Include="Dfa\DFAState.cs" />
-    <Compile Include="Dfa\EdgeMap.cs" />
+    <Compile Include="Dfa\IEdgeMap`1.cs" />
     <Compile Include="Dfa\LexerDFASerializer.cs" />
-    <Compile Include="Dfa\SingletonEdgeMap.cs" />
-    <Compile Include="Dfa\SparseEdgeMap.cs" />
+    <Compile Include="Dfa\SingletonEdgeMap`1.cs" />
+    <Compile Include="Dfa\SparseEdgeMap`1.cs" />
     <Compile Include="DiagnosticErrorListener.cs" />
     <Compile Include="FailedPredicateException.cs" />
+    <Compile Include="IAntlrErrorListener`1.cs" />
+    <Compile Include="IAntlrErrorStrategy.cs" />
+    <Compile Include="ICharStream.cs" />
+    <Compile Include="IIntStream.cs" />
     <Compile Include="InputMismatchException.cs" />
-    <Compile Include="IntStream.cs" />
+    <Compile Include="IParserErrorListener.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="LexerNoViableAltException.cs" />
-    <Compile Include="Misc\AbstractEqualityComparator.cs" />
+    <Compile Include="Misc\AbstractEqualityComparator`1.cs" />
     <Compile Include="Misc\Args.cs" />
-    <Compile Include="Misc\Array2DHashSet.cs" />
-    <Compile Include="Misc\DoubleKeyMap.cs" />
-    <Compile Include="Misc\EqualityComparator.cs" />
-    <Compile Include="Misc\FlexibleHashMap.cs" />
-    <Compile Include="Misc\Func0.cs" />
-    <Compile Include="Misc\Func1.cs" />
+    <Compile Include="Misc\Array2DHashSet`1.cs" />
+    <Compile Include="Misc\DoubleKeyMap`3.cs" />
+    <Compile Include="Misc\FlexibleHashMap`2.cs" />
+    <Compile Include="Misc\IEqualityComparator`1.cs" />
+    <Compile Include="Misc\IFunc0`1.cs" />
+    <Compile Include="Misc\IFunc1`2.cs" />
+    <Compile Include="Misc\IIntSet.cs" />
     <Compile Include="Misc\IntegerList.cs" />
     <Compile Include="Misc\IntegerStack.cs" />
     <Compile Include="Misc\Interval.cs" />
     <Compile Include="Misc\IntervalSet.cs" />
-    <Compile Include="Misc\IntSet.cs" />
-    <Compile Include="Misc\MultiMap.cs" />
+    <Compile Include="Misc\IPredicate`1.cs" />
+    <Compile Include="Misc\MultiMap`2.cs" />
     <Compile Include="Misc\ObjectEqualityComparator.cs" />
-    <Compile Include="Misc\OrderedHashSet.cs" />
+    <Compile Include="Misc\OrderedHashSet`1.cs" />
     <Compile Include="Misc\ParseCanceledException.cs" />
-    <Compile Include="Misc\Predicate.cs" />
     <Compile Include="Misc\RuleDependencyChecker.cs" />
     <Compile Include="Misc\RuleDependencyProcessor.cs" />
     <Compile Include="Misc\TestRig.cs" />
     <Compile Include="Misc\Tuple.cs" />
+    <Compile Include="Misc\Tuple`2.cs" />
+    <Compile Include="Misc\Tuple`3.cs" />
     <Compile Include="Misc\Utils.cs" />
     <Compile Include="NoViableAltException.cs" />
     <Compile Include="Parser.cs" />
-    <Compile Include="ParserErrorListener.cs" />
     <Compile Include="ParserRuleContext.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="ProxyErrorListener.cs" />
+    <Compile Include="ProxyErrorListener`1.cs" />
     <Compile Include="ProxyParserErrorListener.cs" />
     <Compile Include="RecognitionException.cs" />
-    <Compile Include="Recognizer.cs" />
+    <Compile Include="Recognizer`2.cs" />
     <Compile Include="RuleContext.cs" />
-    <Compile Include="Token.cs" />
-    <Compile Include="TokenFactory.cs" />
-    <Compile Include="TokenSource.cs" />
-    <Compile Include="TokenStream.cs" />
     <Compile Include="TokenStreamRewriter.cs" />
-    <Compile Include="Tree\AbstractParseTreeVisitor.cs" />
-    <Compile Include="Tree\ErrorNode.cs" />
+    <Compile Include="Tree\AbstractParseTreeVisitor`1.cs" />
     <Compile Include="Tree\ErrorNodeImpl.cs" />
-    <Compile Include="Tree\ParseTree.cs" />
-    <Compile Include="Tree\ParseTreeListener.cs" />
-    <Compile Include="Tree\ParseTreeProperty.cs" />
-    <Compile Include="Tree\ParseTreeVisitor.cs" />
+    <Compile Include="Tree\IErrorNode.cs" />
+    <Compile Include="Tree\IParseTree.cs" />
+    <Compile Include="Tree\IParseTreeListener.cs" />
+    <Compile Include="Tree\IParseTreeVisitor`1.cs" />
+    <Compile Include="Tree\IRuleNode.cs" />
+    <Compile Include="Tree\ISyntaxTree.cs" />
+    <Compile Include="Tree\ITerminalNode.cs" />
+    <Compile Include="Tree\ITree.cs" />
+    <Compile Include="Tree\ParseTreeProperty`1.cs" />
     <Compile Include="Tree\ParseTreeWalker.cs" />
-    <Compile Include="Tree\RuleNode.cs" />
-    <Compile Include="Tree\SyntaxTree.cs" />
-    <Compile Include="Tree\TerminalNode.cs" />
     <Compile Include="Tree\TerminalNodeImpl.cs" />
-    <Compile Include="Tree\Tree.cs" />
     <Compile Include="Tree\Trees.cs" />
     <Compile Include="UnbufferedCharStream.cs" />
     <Compile Include="UnbufferedTokenStream.cs" />
-    <Compile Include="WritableToken.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Antlr4.Runtime/Atn/ATN.cs b/Antlr4.Runtime/Atn/ATN.cs
index 0923f0171..7c23fe57f 100644
--- a/Antlr4.Runtime/Atn/ATN.cs
+++ b/Antlr4.Runtime/Atn/ATN.cs
@@ -44,7 +44,7 @@ namespace Antlr4.Runtime.Atn
 		public const int Lexer = 2;
 
 		[NotNull]
-		public readonly IList<ATNState> states = new AList<ATNState>();
+		public readonly IList<ATNState> states = new List<ATNState>();
 
 		/// <summary>
 		/// Each subrule/rule is a decision point and we must track them so we
@@ -56,7 +56,7 @@ namespace Antlr4.Runtime.Atn
 		/// all the rules, subrules, optional blocks, ()+, ()* etc...
 		/// </remarks>
 		[NotNull]
-		public readonly IList<DecisionState> decisionToState = new AList<DecisionState>();
+		public readonly IList<DecisionState> decisionToState = new List<DecisionState>();
 
 		public RuleStartState[] ruleToStartState;
 
@@ -75,13 +75,13 @@ namespace Antlr4.Runtime.Atn
 		public int[] ruleToActionIndex;
 
 		[NotNull]
-		public readonly IList<TokensStartState> modeToStartState = new AList<TokensStartState
+		public readonly IList<TokensStartState> modeToStartState = new List<TokensStartState
 			>();
 
 		/// <summary>used during construction from grammar AST</summary>
 		internal int stateNumber = 0;
 
-		private readonly ConcurrentMap<PredictionContext, PredictionContext> contextCache
+		private readonly IConcurrentMap<PredictionContext, PredictionContext> contextCache
 			 = new ConcurrentHashMap<PredictionContext, PredictionContext>();
 
 		[NotNull]
@@ -90,7 +90,7 @@ namespace Antlr4.Runtime.Atn
 		[NotNull]
 		public DFA[] modeToDFA = new DFA[0];
 
-		protected internal readonly ConcurrentMap<int, int> LL1Table = new ConcurrentHashMap
+		protected internal readonly IConcurrentMap<int, int> LL1Table = new ConcurrentHashMap
 			<int, int>();
 
 		/// <summary>Used for runtime deserialization of ATNs from strings</summary>
diff --git a/Antlr4.Runtime/Atn/ATNConfig.cs b/Antlr4.Runtime/Atn/ATNConfig.cs
index 51c3ef05a..14f69e87f 100644
--- a/Antlr4.Runtime/Atn/ATNConfig.cs
+++ b/Antlr4.Runtime/Atn/ATNConfig.cs
@@ -293,8 +293,8 @@ namespace Antlr4.Runtime.Atn
 			{
 				return false;
 			}
-			Deque<PredictionContext> leftWorkList = new ArrayDeque<PredictionContext>();
-			Deque<PredictionContext> rightWorkList = new ArrayDeque<PredictionContext>();
+			IDeque<PredictionContext> leftWorkList = new ArrayDeque<PredictionContext>();
+			IDeque<PredictionContext> rightWorkList = new ArrayDeque<PredictionContext>();
 			leftWorkList.AddItem(GetContext());
 			rightWorkList.AddItem(subconfig.GetContext());
 			while (!leftWorkList.IsEmpty())
@@ -388,7 +388,7 @@ namespace Antlr4.Runtime.Atn
 			builder.Append("rankdir=LR;\n");
 			IDictionary<PredictionContext, PredictionContext> visited = new IdentityHashMap<PredictionContext
 				, PredictionContext>();
-			Deque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
+			IDeque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
 			workList.AddItem(GetContext());
 			visited.Put(GetContext(), GetContext());
 			while (!workList.IsEmpty())
diff --git a/Antlr4.Runtime/Atn/ATNConfigSet.cs b/Antlr4.Runtime/Atn/ATNConfigSet.cs
index 087d11f79..bb38eeb25 100644
--- a/Antlr4.Runtime/Atn/ATNConfigSet.cs
+++ b/Antlr4.Runtime/Atn/ATNConfigSet.cs
@@ -73,11 +73,11 @@ namespace Antlr4.Runtime.Atn
 		/// <code>null</code>
 		/// for read-only sets stored in the DFA.
 		/// </summary>
-		private readonly AList<ATNConfig> unmerged;
+		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 AList<ATNConfig> configs;
+		private readonly List<ATNConfig> configs;
 
 		private int uniqueAlt;
 
@@ -112,8 +112,8 @@ namespace Antlr4.Runtime.Atn
 			// 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 AList<ATNConfig>();
-			this.configs = new AList<ATNConfig>();
+			this.unmerged = new List<ATNConfig>();
+			this.configs = new List<ATNConfig>();
 			this.uniqueAlt = ATN.InvalidAltNumber;
 		}
 
@@ -130,15 +130,15 @@ namespace Antlr4.Runtime.Atn
 				if (!set.IsReadOnly())
 				{
 					this.mergedConfigs = (Dictionary<long, ATNConfig>)set.mergedConfigs.Clone();
-					this.unmerged = (AList<ATNConfig>)set.unmerged.Clone();
+					this.unmerged = (List<ATNConfig>)set.unmerged.Clone();
 				}
 				else
 				{
 					this.mergedConfigs = new Dictionary<long, ATNConfig>(set.configs.Count);
-					this.unmerged = new AList<ATNConfig>();
+					this.unmerged = new List<ATNConfig>();
 				}
 			}
-			this.configs = (AList<ATNConfig>)set.configs.Clone();
+			this.configs = (List<ATNConfig>)set.configs.Clone();
 			this.dipsIntoOuterContext = set.dipsIntoOuterContext;
 			this.hasSemanticContext = set.hasSemanticContext;
 			this.outermostConfigSet = set.outermostConfigSet;
@@ -190,7 +190,7 @@ namespace Antlr4.Runtime.Atn
 					iterator.Remove();
 				}
 			}
-			ListIterator<ATNConfig> iterator2 = unmerged.ListIterator();
+			IListIterator<ATNConfig> iterator2 = unmerged.ListIterator();
 			while (iterator2.HasNext())
 			{
 				if (iterator2.Next().IsHidden())
@@ -517,7 +517,7 @@ namespace Antlr4.Runtime.Atn
 		public virtual string ToString(bool showContext)
 		{
 			StringBuilder buf = new StringBuilder();
-			IList<ATNConfig> sortedConfigs = new AList<ATNConfig>(configs);
+			IList<ATNConfig> sortedConfigs = new List<ATNConfig>(configs);
 			sortedConfigs.Sort(new _IComparer_467());
 			buf.Append("[");
 			for (int i = 0; i < sortedConfigs.Count; i++)
diff --git a/Antlr4.Runtime/Atn/ATNSimulator.cs b/Antlr4.Runtime/Atn/ATNSimulator.cs
index afd87248f..ca568fb43 100644
--- a/Antlr4.Runtime/Atn/ATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ATNSimulator.cs
@@ -86,7 +86,7 @@ namespace Antlr4.Runtime.Atn
 				data[i] = (char)(data[i] - 2);
 			}
 			ATN atn = new ATN();
-			IList<IntervalSet> sets = new AList<IntervalSet>();
+			IList<IntervalSet> sets = new List<IntervalSet>();
 			int p = 0;
 			int version = ToInt(data[p++]);
 			if (version != SerializedVersion)
@@ -101,9 +101,9 @@ namespace Antlr4.Runtime.Atn
 			//
 			// STATES
 			//
-			IList<Tuple<LoopEndState, int>> loopBackStateNumbers = new AList<Tuple<LoopEndState
+			IList<Tuple<LoopEndState, int>> loopBackStateNumbers = new List<Tuple<LoopEndState
 				, int>>();
-			IList<Tuple<BlockStartState, int>> endStateNumbers = new AList<Tuple<BlockStartState
+			IList<Tuple<BlockStartState, int>> endStateNumbers = new List<Tuple<BlockStartState
 				, int>>();
 			int nstates = ToInt(data[p++]);
 			for (int i_1 = 1; i_1 <= nstates; i_1++)
@@ -517,7 +517,7 @@ namespace Antlr4.Runtime.Atn
 					}
 					if (optimizedTransitions == null)
 					{
-						optimizedTransitions = new AList<Transition>();
+						optimizedTransitions = new List<Transition>();
 						for (int j = 0; j < i_1; j++)
 						{
 							optimizedTransitions.AddItem(state.GetOptimizedTransition(i_1));
@@ -612,7 +612,7 @@ namespace Antlr4.Runtime.Atn
 					removedEdges++;
 					if (optimizedTransitions == null)
 					{
-						optimizedTransitions = new AList<Transition>();
+						optimizedTransitions = new List<Transition>();
 						for (int j_1 = 0; j_1 < i; j_1++)
 						{
 							optimizedTransitions.AddItem(state.GetOptimizedTransition(j_1));
@@ -688,7 +688,7 @@ nextState_break: ;
 				{
 					continue;
 				}
-				IList<Transition> optimizedTransitions = new AList<Transition>();
+				IList<Transition> optimizedTransitions = new List<Transition>();
 				for (int i_1 = 0; i_1 < decision.GetNumberOfOptimizedTransitions(); i_1++)
 				{
 					if (!setTransitions.Contains(i_1))
@@ -800,7 +800,7 @@ nextState_break: ;
 				return true;
 			}
 			BitSet reachable = new BitSet(atn.states.Count);
-			Deque<ATNState> worklist = new ArrayDeque<ATNState>();
+			IDeque<ATNState> worklist = new ArrayDeque<ATNState>();
 			worklist.AddItem(transition.followState);
 			while (!worklist.IsEmpty())
 			{
diff --git a/Antlr4.Runtime/Atn/ATNState.cs b/Antlr4.Runtime/Atn/ATNState.cs
index 7bbf6ac39..256b7397c 100644
--- a/Antlr4.Runtime/Atn/ATNState.cs
+++ b/Antlr4.Runtime/Atn/ATNState.cs
@@ -139,7 +139,7 @@ namespace Antlr4.Runtime.Atn
 		/// <summary>Track the transitions emanating from this ATN state.</summary>
 		/// <remarks>Track the transitions emanating from this ATN state.</remarks>
 		protected internal readonly IList<Antlr4.Runtime.Atn.Transition> transitions = new 
-			AList<Antlr4.Runtime.Atn.Transition>(InitialNumTransitions);
+			List<Antlr4.Runtime.Atn.Transition>(InitialNumTransitions);
 
 		protected internal IList<Antlr4.Runtime.Atn.Transition> optimizedTransitions;
 
@@ -272,7 +272,7 @@ namespace Antlr4.Runtime.Atn
 		{
 			if (!IsOptimized())
 			{
-				optimizedTransitions = new AList<Antlr4.Runtime.Atn.Transition>();
+				optimizedTransitions = new List<Antlr4.Runtime.Atn.Transition>();
 			}
 			optimizedTransitions.AddItem(e);
 		}
diff --git a/Antlr4.Runtime/Atn/ArrayPredictionContext.cs b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
index a7ff42864..133282b8a 100644
--- a/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
@@ -222,8 +222,8 @@ namespace Antlr4.Runtime.Atn
 		private bool Equals(Antlr4.Runtime.Atn.ArrayPredictionContext other, ICollection<
 			PredictionContextCache.IdentityCommutativePredictionContextOperands> visited)
 		{
-			Deque<PredictionContext> selfWorkList = new ArrayDeque<PredictionContext>();
-			Deque<PredictionContext> otherWorkList = new ArrayDeque<PredictionContext>();
+			IDeque<PredictionContext> selfWorkList = new ArrayDeque<PredictionContext>();
+			IDeque<PredictionContext> otherWorkList = new ArrayDeque<PredictionContext>();
 			selfWorkList.Push(this);
 			otherWorkList.Push(other);
 			while (!selfWorkList.IsEmpty())
diff --git a/Antlr4.Runtime/Atn/LL1Analyzer.cs b/Antlr4.Runtime/Atn/LL1Analyzer.cs
index c68cbf97a..10975f632 100644
--- a/Antlr4.Runtime/Atn/LL1Analyzer.cs
+++ b/Antlr4.Runtime/Atn/LL1Analyzer.cs
@@ -45,7 +45,7 @@ namespace Antlr4.Runtime.Atn
 		/// Special value added to the lookahead sets to indicate that we hit
 		/// a predicate during analysis if seeThruPreds==false.
 		/// </remarks>
-		public const int HitPred = Token.InvalidType;
+		public const int HitPred = IToken.InvalidType;
 
 		[NotNull]
 		public readonly ATN atn;
@@ -103,13 +103,13 @@ namespace Antlr4.Runtime.Atn
 		/// is
 		/// <code>PredictionContext#EMPTY_LOCAL</code>
 		/// ,
-		/// <see cref="Antlr4.Runtime.Token.Epsilon">EPSILON</see>
+		/// <see cref="Antlr4.Runtime.IToken.Epsilon">EPSILON</see>
 		/// is in set if we can reach end of rule. If
 		/// <code>ctx</code>
 		/// is
 		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
 		/// ,
-		/// <see cref="Antlr4.Runtime.IntStream.Eof">EOF</see>
+		/// <see cref="Antlr4.Runtime.IIntStream.Eof">EOF</see>
 		/// is in set
 		/// if we can reach end of rule.
 		/// </summary>
@@ -150,14 +150,14 @@ namespace Antlr4.Runtime.Atn
 			{
 				if (PredictionContext.IsEmptyLocal(ctx))
 				{
-					look.Add(Token.Epsilon);
+					look.Add(IToken.Epsilon);
 					return;
 				}
 				else
 				{
 					if (ctx.IsEmpty() && addEOF)
 					{
-						look.Add(Token.Eof);
+						look.Add(IToken.Eof);
 						return;
 					}
 				}
@@ -208,7 +208,7 @@ namespace Antlr4.Runtime.Atn
 						{
 							if (t.GetType() == typeof(WildcardTransition))
 							{
-								look.AddAll(IntervalSet.Of(Token.MinUserTokenType, atn.maxTokenType));
+								look.AddAll(IntervalSet.Of(IToken.MinUserTokenType, atn.maxTokenType));
 							}
 							else
 							{
@@ -218,7 +218,7 @@ namespace Antlr4.Runtime.Atn
 								{
 									if (t is NotSetTransition)
 									{
-										set = set.Complement(IntervalSet.Of(Token.MinUserTokenType, atn.maxTokenType));
+										set = set.Complement(IntervalSet.Of(IToken.MinUserTokenType, atn.maxTokenType));
 									}
 									look.AddAll(set);
 								}
diff --git a/Antlr4.Runtime/Atn/LexerATNSimulator.cs b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
index 8962464d7..ffbbfbf50 100644
--- a/Antlr4.Runtime/Atn/LexerATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
@@ -53,7 +53,7 @@ namespace Antlr4.Runtime.Atn
 		/// 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.IntStream.Mark()">Antlr4.Runtime.IntStream.Mark()</see>
+		/// <see cref="Antlr4.Runtime.IIntStream.Mark()">Antlr4.Runtime.IIntStream.Mark()</see>
 		/// 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
@@ -132,7 +132,7 @@ namespace Antlr4.Runtime.Atn
 			this.startIndex = simulator.startIndex;
 		}
 
-		public virtual int Match(CharStream input, int mode)
+		public virtual int Match(ICharStream input, int mode)
 		{
 			match_calls++;
 			this.mode = mode;
@@ -167,7 +167,7 @@ namespace Antlr4.Runtime.Atn
 		}
 
 		// only called from test code from outside
-		protected internal virtual int MatchATN(CharStream input)
+		protected internal virtual int MatchATN(ICharStream input)
 		{
 			ATNState startState = atn.modeToStartState[mode];
 			int old_mode = mode;
@@ -189,7 +189,7 @@ namespace Antlr4.Runtime.Atn
 			return predict;
 		}
 
-		protected internal virtual int ExecATN(CharStream input, DFAState ds0)
+		protected internal virtual int ExecATN(ICharStream input, DFAState ds0)
 		{
 			//System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
 			int t = input.La(1);
@@ -252,12 +252,12 @@ namespace Antlr4.Runtime.Atn
 				if (target.isAcceptState)
 				{
 					CaptureSimState(prevAccept, input, target);
-					if (t == IntStream.Eof)
+					if (t == IIntStream.Eof)
 					{
 						break;
 					}
 				}
-				if (t != IntStream.Eof)
+				if (t != IIntStream.Eof)
 				{
 					Consume(input);
 					t = input.La(1);
@@ -269,7 +269,7 @@ namespace Antlr4.Runtime.Atn
 		}
 
 		protected internal virtual int FailOrAccept(LexerATNSimulator.SimState prevAccept
-			, CharStream input, ATNConfigSet reach, int t)
+			, ICharStream input, ATNConfigSet reach, int t)
 		{
 			if (prevAccept.dfaState != null)
 			{
@@ -282,9 +282,9 @@ namespace Antlr4.Runtime.Atn
 			else
 			{
 				// if no accept and EOF is first char, return EOF
-				if (t == IntStream.Eof && input.Index() == startIndex)
+				if (t == IIntStream.Eof && input.Index() == startIndex)
 				{
-					return Token.Eof;
+					return IToken.Eof;
 				}
 				throw new LexerNoViableAltException(recog, input, startIndex, reach);
 			}
@@ -299,7 +299,7 @@ namespace Antlr4.Runtime.Atn
 		/// is a return
 		/// parameter.
 		/// </summary>
-		protected internal virtual void GetReachableConfigSet(CharStream input, ATNConfigSet
+		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
@@ -331,7 +331,7 @@ namespace Antlr4.Runtime.Atn
 			}
 		}
 
-		protected internal virtual void Accept(CharStream input, int ruleIndex, int actionIndex
+		protected internal virtual void Accept(ICharStream input, int ruleIndex, int actionIndex
 			, int index, int line, int charPos)
 		{
 			if (actionIndex >= 0 && recog != null)
@@ -342,7 +342,7 @@ namespace Antlr4.Runtime.Atn
 			input.Seek(index);
 			this.line = line;
 			this.charPositionInLine = charPos;
-			if (input.La(1) != IntStream.Eof)
+			if (input.La(1) != IIntStream.Eof)
 			{
 				Consume(input);
 			}
@@ -359,7 +359,7 @@ namespace Antlr4.Runtime.Atn
 		}
 
 		[NotNull]
-		protected internal virtual ATNConfigSet ComputeStartState(CharStream input, ATNState
+		protected internal virtual ATNConfigSet ComputeStartState(ICharStream input, ATNState
 			 p)
 		{
 			PredictionContext initialContext = PredictionContext.EmptyFull;
@@ -394,7 +394,7 @@ namespace Antlr4.Runtime.Atn
 		/// <code>false</code>
 		/// .
 		/// </returns>
-		protected internal virtual bool Closure(CharStream input, ATNConfig config, ATNConfigSet
+		protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet
 			 configs, bool speculative)
 		{
 			if (config.GetState() is RuleStopState)
@@ -454,7 +454,7 @@ namespace Antlr4.Runtime.Atn
 
 		// side-effect: can alter configs.hasSemanticContext
 		[Nullable]
-		public virtual ATNConfig GetEpsilonTarget(CharStream input, ATNConfig config, Transition
+		public virtual ATNConfig GetEpsilonTarget(ICharStream input, ATNConfig config, Transition
 			 t, ATNConfigSet configs, bool speculative)
 		{
 			ATNConfig c;
@@ -530,10 +530,10 @@ namespace Antlr4.Runtime.Atn
 		/// is
 		/// <code>true</code>
 		/// , this method was called before
-		/// <see cref="Consume(Antlr4.Runtime.CharStream)">Consume(Antlr4.Runtime.CharStream)
+		/// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
 		/// 	</see>
 		/// for the matched character. This method should call
-		/// <see cref="Consume(Antlr4.Runtime.CharStream)">Consume(Antlr4.Runtime.CharStream)
+		/// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
 		/// 	</see>
 		/// before evaluating the predicate to ensure position
 		/// sensitive values, including
@@ -550,7 +550,7 @@ namespace Antlr4.Runtime.Atn
 		/// and the simulator
 		/// to the original state before returning (i.e. undo the actions made by the
 		/// call to
-		/// <see cref="Consume(Antlr4.Runtime.CharStream)">Consume(Antlr4.Runtime.CharStream)
+		/// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
 		/// 	</see>
 		/// .
 		/// </remarks>
@@ -572,7 +572,7 @@ namespace Antlr4.Runtime.Atn
 		/// <code>true</code>
 		/// .
 		/// </returns>
-		protected internal virtual bool EvaluatePredicate(CharStream input, int ruleIndex
+		protected internal virtual bool EvaluatePredicate(ICharStream input, int ruleIndex
 			, int predIndex, bool speculative)
 		{
 			// assume true if no recognizer was provided
@@ -603,7 +603,7 @@ namespace Antlr4.Runtime.Atn
 		}
 
 		protected internal virtual void CaptureSimState(LexerATNSimulator.SimState settings
-			, CharStream input, DFAState dfaState)
+			, ICharStream input, DFAState dfaState)
 		{
 			settings.index = input.Index();
 			settings.line = line;
@@ -687,7 +687,7 @@ namespace Antlr4.Runtime.Atn
 		/// <summary>Get the text matched so far for the current token.</summary>
 		/// <remarks>Get the text matched so far for the current token.</remarks>
 		[NotNull]
-		public virtual string GetText(CharStream input)
+		public virtual string GetText(ICharStream input)
 		{
 			// index is first lookahead char, don't include.
 			return input.GetText(Interval.Of(startIndex, input.Index() - 1));
@@ -713,7 +713,7 @@ namespace Antlr4.Runtime.Atn
 			this.charPositionInLine = charPositionInLine;
 		}
 
-		public virtual void Consume(CharStream input)
+		public virtual void Consume(ICharStream input)
 		{
 			int curChar = input.La(1);
 			if (curChar == '\n')
diff --git a/Antlr4.Runtime/Atn/ParserATNSimulator.cs b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
index 461f85061..60d6074fb 100644
--- a/Antlr4.Runtime/Atn/ParserATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
@@ -232,7 +232,8 @@ namespace Antlr4.Runtime.Atn
 		/// <code>true</code>
 		/// , ambiguous alternatives are reported when they are
 		/// encountered within
-		/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, ITokenStream, int, SimulatorState)">ExecATN(Antlr4.Runtime.Dfa.DFA, ITokenStream, int, SimulatorState)
+		/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)
+		/// 	">ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)
 		/// 	</see>
 		/// . When
 		/// <code>false</code>
@@ -507,7 +508,7 @@ namespace Antlr4.Runtime.Atn
 					}
 				}
 				s = target;
-				if (!s.isAcceptState && t != IntStream.Eof)
+				if (!s.isAcceptState && t != IIntStream.Eof)
 				{
 					input.Consume();
 					t = input.La(1);
@@ -786,7 +787,7 @@ namespace Antlr4.Runtime.Atn
 					return predictedAlt;
 				}
 				previous = nextState;
-				if (t != IntStream.Eof)
+				if (t != IIntStream.Eof)
 				{
 					input.Consume();
 					t = input.La(1);
@@ -852,7 +853,7 @@ namespace Antlr4.Runtime.Atn
 				return new SimulatorState(previous.outerContext, existingTarget, useContext, remainingGlobalContext
 					);
 			}
-			IList<ATNConfig> closureConfigs = new AList<ATNConfig>(s0.configs);
+			IList<ATNConfig> closureConfigs = new List<ATNConfig>(s0.configs);
 			IntegerList contextElements = null;
 			ATNConfigSet reach = new ATNConfigSet();
 			bool stepIntoGlobal;
@@ -870,11 +871,11 @@ namespace Antlr4.Runtime.Atn
 					if (c.GetState() is RuleStopState)
 					{
 						System.Diagnostics.Debug.Assert(c.GetContext().IsEmpty());
-						if (useContext && !c.GetReachesIntoOuterContext() || t == IntStream.Eof)
+						if (useContext && !c.GetReachesIntoOuterContext() || t == IIntStream.Eof)
 						{
 							if (skippedStopStates == null)
 							{
-								skippedStopStates = new AList<ATNConfig>();
+								skippedStopStates = new List<ATNConfig>();
 							}
 							skippedStopStates.AddItem(c);
 						}
@@ -903,7 +904,7 @@ namespace Antlr4.Runtime.Atn
 				Closure(reachIntermediate, reach, collectPredicates, hasMoreContext, contextCache
 					);
 				stepIntoGlobal = reach.GetDipsIntoOuterContext();
-				if (t == IntStream.Eof)
+				if (t == IIntStream.Eof)
 				{
 					reach = RemoveAllConfigsNotInRuleStopState(reach, contextCache);
 				}
@@ -1193,7 +1194,7 @@ namespace Antlr4.Runtime.Atn
 		public virtual DFAState.PredPrediction[] GetPredicatePredictions(BitSet ambigAlts
 			, SemanticContext[] altToPred)
 		{
-			IList<DFAState.PredPrediction> pairs = new AList<DFAState.PredPrediction>();
+			IList<DFAState.PredPrediction> pairs = new List<DFAState.PredPrediction>();
 			bool containsPredicate = false;
 			for (int i = 1; i < altToPred.Length; i++)
 			{
@@ -1619,7 +1620,7 @@ namespace Antlr4.Runtime.Atn
 			{
 				return null;
 			}
-			IList<ATNConfig> configs = new AList<ATNConfig>(configset);
+			IList<ATNConfig> configs = new List<ATNConfig>(configset);
 			configs.Sort(StateAltSortComparator);
 			bool exact = !configset.GetDipsIntoOuterContext() && predictionMode == PredictionMode
 				.LlExactAmbigDetection;
@@ -1823,7 +1824,7 @@ namespace Antlr4.Runtime.Atn
 		[NotNull]
 		public virtual string GetTokenName(int t)
 		{
-			if (t == Token.Eof)
+			if (t == IToken.Eof)
 			{
 				return "EOF";
 			}
diff --git a/Antlr4.Runtime/Atn/PredictionContext.cs b/Antlr4.Runtime/Atn/PredictionContext.cs
index 0a1e6361b..c960f0ee7 100644
--- a/Antlr4.Runtime/Atn/PredictionContext.cs
+++ b/Antlr4.Runtime/Atn/PredictionContext.cs
@@ -336,7 +336,7 @@ namespace Antlr4.Runtime.Atn
 		}
 
 		public static Antlr4.Runtime.Atn.PredictionContext GetCachedContext(Antlr4.Runtime.Atn.PredictionContext
-			 context, ConcurrentMap<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext
+			 context, IConcurrentMap<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext
 			> contextCache, PredictionContext.IdentityHashMap visited)
 		{
 			if (context.IsEmpty())
@@ -439,7 +439,7 @@ namespace Antlr4.Runtime.Atn
 		public virtual string[] ToStrings<_T0>(Recognizer<_T0> recognizer, Antlr4.Runtime.Atn.PredictionContext
 			 stop, int currentState)
 		{
-			IList<string> result = new AList<string>();
+			IList<string> result = new List<string>();
 			for (int perm = 0; ; perm++)
 			{
 				int offset = 0;
diff --git a/Antlr4.Runtime/Atn/SemanticContext.cs b/Antlr4.Runtime/Atn/SemanticContext.cs
index 11038dcbb..69e25e36d 100644
--- a/Antlr4.Runtime/Atn/SemanticContext.cs
+++ b/Antlr4.Runtime/Atn/SemanticContext.cs
@@ -142,7 +142,7 @@ namespace Antlr4.Runtime.Atn
 			}
 		}
 
-		public class PrecedencePredicate : SemanticContext, Comparable<SemanticContext.PrecedencePredicate
+		public class PrecedencePredicate : SemanticContext, IComparable<SemanticContext.PrecedencePredicate
 			>
 		{
 			public readonly int precedence;
@@ -393,7 +393,7 @@ namespace Antlr4.Runtime.Atn
 		private static IList<SemanticContext.PrecedencePredicate> FilterPrecedencePredicates
 			<_T0>(ICollection<_T0> collection) where _T0:SemanticContext
 		{
-			AList<SemanticContext.PrecedencePredicate> result = null;
+			List<SemanticContext.PrecedencePredicate> result = null;
 			for (IEnumerator<SemanticContext> iterator = collection.GetEnumerator(); iterator
 				.HasNext(); )
 			{
@@ -402,7 +402,7 @@ namespace Antlr4.Runtime.Atn
 				{
 					if (result == null)
 					{
-						result = new AList<SemanticContext.PrecedencePredicate>();
+						result = new List<SemanticContext.PrecedencePredicate>();
 					}
 					result.AddItem((SemanticContext.PrecedencePredicate)context);
 					iterator.Remove();
diff --git a/Antlr4.Runtime/Atn/SetTransition.cs b/Antlr4.Runtime/Atn/SetTransition.cs
index b84526e0a..fa8513a9c 100644
--- a/Antlr4.Runtime/Atn/SetTransition.cs
+++ b/Antlr4.Runtime/Atn/SetTransition.cs
@@ -46,7 +46,7 @@ namespace Antlr4.Runtime.Atn
 			// TODO (sam): should we really allow null here?
 			if (set == null)
 			{
-				set = IntervalSet.Of(Token.InvalidType);
+				set = IntervalSet.Of(IToken.InvalidType);
 			}
 			this.set = set;
 		}
diff --git a/Antlr4.Runtime/BailErrorStrategy.cs b/Antlr4.Runtime/BailErrorStrategy.cs
index c492e577b..3e29e46bd 100644
--- a/Antlr4.Runtime/BailErrorStrategy.cs
+++ b/Antlr4.Runtime/BailErrorStrategy.cs
@@ -73,7 +73,7 @@ namespace Antlr4.Runtime
 		/// successfully recovers, it won't throw an exception.
 		/// </remarks>
 		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public override Token RecoverInline(Parser recognizer)
+		public override IToken RecoverInline(Parser recognizer)
 		{
 			InputMismatchException e = new InputMismatchException(recognizer);
 			for (ParserRuleContext context = recognizer.GetContext(); context != null; context
diff --git a/Antlr4.Runtime/BaseErrorListener.cs b/Antlr4.Runtime/BaseErrorListener.cs
index 6cb07b034..157291305 100644
--- a/Antlr4.Runtime/BaseErrorListener.cs
+++ b/Antlr4.Runtime/BaseErrorListener.cs
@@ -39,7 +39,7 @@ namespace Antlr4.Runtime
 	{
 		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
 			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
-			Token
+			IToken
 		{
 		}
 
diff --git a/Antlr4.Runtime/BufferedTokenStream.cs b/Antlr4.Runtime/BufferedTokenStream.cs
index 171d6072b..fa3183145 100644
--- a/Antlr4.Runtime/BufferedTokenStream.cs
+++ b/Antlr4.Runtime/BufferedTokenStream.cs
@@ -78,7 +78,7 @@ namespace Antlr4.Runtime
 		/// chunks of it later. This list captures everything so we can access
 		/// complete input text.
 		/// </remarks>
-		protected internal IList<Token> tokens = new AList<Token>(100);
+		protected internal IList<IToken> tokens = new List<IToken>(100);
 
 		/// <summary>
 		/// The index into the tokens list of the current token (next token
@@ -214,13 +214,13 @@ namespace Antlr4.Runtime
 			}
 			for (int i = 0; i < n; i++)
 			{
-				Token t = tokenSource.NextToken();
+				IToken t = tokenSource.NextToken();
 				if (t is IWritableToken)
 				{
 					((IWritableToken)t).SetTokenIndex(tokens.Count);
 				}
 				tokens.AddItem(t);
-				if (t.GetType() == Token.Eof)
+				if (t.GetType() == IToken.Eof)
 				{
 					fetchedEOF = true;
 					return i + 1;
@@ -229,7 +229,7 @@ namespace Antlr4.Runtime
 			return n;
 		}
 
-		public virtual Token Get(int i)
+		public virtual IToken Get(int i)
 		{
 			if (i < 0 || i >= tokens.Count)
 			{
@@ -241,22 +241,22 @@ namespace Antlr4.Runtime
 
 		/// <summary>Get all tokens from start..stop inclusively.</summary>
 		/// <remarks>Get all tokens from start..stop inclusively.</remarks>
-		public virtual IList<Token> Get(int start, int stop)
+		public virtual IList<IToken> Get(int start, int stop)
 		{
 			if (start < 0 || stop < 0)
 			{
 				return null;
 			}
 			LazyInit();
-			IList<Token> subset = new AList<Token>();
+			IList<IToken> subset = new List<IToken>();
 			if (stop >= tokens.Count)
 			{
 				stop = tokens.Count - 1;
 			}
 			for (int i = start; i <= stop; i++)
 			{
-				Token t = tokens[i];
-				if (t.GetType() == Token.Eof)
+				IToken t = tokens[i];
+				if (t.GetType() == IToken.Eof)
 				{
 					break;
 				}
@@ -270,7 +270,7 @@ namespace Antlr4.Runtime
 			return Lt(i).GetType();
 		}
 
-		protected internal virtual Token Lb(int k)
+		protected internal virtual IToken Lb(int k)
 		{
 			if ((p - k) < 0)
 			{
@@ -279,7 +279,7 @@ namespace Antlr4.Runtime
 			return tokens[p - k];
 		}
 
-		public virtual Token Lt(int k)
+		public virtual IToken Lt(int k)
 		{
 			LazyInit();
 			if (k == 0)
@@ -351,12 +351,12 @@ namespace Antlr4.Runtime
 			p = -1;
 		}
 
-		public virtual IList<Token> GetTokens()
+		public virtual IList<IToken> GetTokens()
 		{
 			return tokens;
 		}
 
-		public virtual IList<Token> GetTokens(int start, int stop)
+		public virtual IList<IToken> GetTokens(int start, int stop)
 		{
 			return GetTokens(start, stop, null);
 		}
@@ -372,7 +372,7 @@ namespace Antlr4.Runtime
 		/// if no tokens were found.  This
 		/// method looks at both on and off channel tokens.
 		/// </summary>
-		public virtual IList<Token> GetTokens(int start, int stop, BitSet types)
+		public virtual IList<IToken> GetTokens(int start, int stop, BitSet types)
 		{
 			LazyInit();
 			if (start < 0 || stop >= tokens.Count || stop < 0 || start >= tokens.Count)
@@ -385,10 +385,10 @@ namespace Antlr4.Runtime
 				return null;
 			}
 			// list = tokens[start:stop]:{T t, t.getType() in types}
-			IList<Token> filteredTokens = new AList<Token>();
+			IList<IToken> filteredTokens = new List<IToken>();
 			for (int i = start; i <= stop; i++)
 			{
-				Token t = tokens[i];
+				IToken t = tokens[i];
 				if (types == null || types.Get(t.GetType()))
 				{
 					filteredTokens.AddItem(t);
@@ -401,7 +401,7 @@ namespace Antlr4.Runtime
 			return filteredTokens;
 		}
 
-		public virtual IList<Token> GetTokens(int start, int stop, int ttype)
+		public virtual IList<IToken> GetTokens(int start, int stop, int ttype)
 		{
 			BitSet s = new BitSet(ttype);
 			s.Set(ttype);
@@ -425,14 +425,14 @@ namespace Antlr4.Runtime
 		protected internal virtual int NextTokenOnChannel(int i, int channel)
 		{
 			Sync(i);
-			Token token = tokens[i];
+			IToken token = tokens[i];
 			if (i >= Size())
 			{
 				return -1;
 			}
 			while (token.GetChannel() != channel)
 			{
-				if (token.GetType() == Token.Eof)
+				if (token.GetType() == IToken.Eof)
 				{
 					return -1;
 				}
@@ -480,7 +480,7 @@ namespace Antlr4.Runtime
 		/// <code>-1</code>
 		/// , find any non default channel token.
 		/// </summary>
-		public virtual IList<Token> GetHiddenTokensToRight(int tokenIndex, int channel)
+		public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex, int channel)
 		{
 			LazyInit();
 			if (tokenIndex < 0 || tokenIndex >= tokens.Count)
@@ -509,7 +509,7 @@ namespace Antlr4.Runtime
 		/// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
 		/// or EOF.
 		/// </summary>
-		public virtual IList<Token> GetHiddenTokensToRight(int tokenIndex)
+		public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex)
 		{
 			return GetHiddenTokensToRight(tokenIndex, -1);
 		}
@@ -525,7 +525,7 @@ namespace Antlr4.Runtime
 		/// <code>-1</code>
 		/// , find any non default channel token.
 		/// </summary>
-		public virtual IList<Token> GetHiddenTokensToLeft(int tokenIndex, int channel)
+		public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex, int channel)
 		{
 			LazyInit();
 			if (tokenIndex < 0 || tokenIndex >= tokens.Count)
@@ -551,18 +551,18 @@ namespace Antlr4.Runtime
 		/// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
 		/// .
 		/// </summary>
-		public virtual IList<Token> GetHiddenTokensToLeft(int tokenIndex)
+		public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex)
 		{
 			return GetHiddenTokensToLeft(tokenIndex, -1);
 		}
 
-		protected internal virtual IList<Token> FilterForChannel(int from, int to, int channel
+		protected internal virtual IList<IToken> FilterForChannel(int from, int to, int channel
 			)
 		{
-			IList<Token> hidden = new AList<Token>();
+			IList<IToken> hidden = new List<IToken>();
 			for (int i = from; i <= to; i++)
 			{
-				Token t = tokens[i];
+				IToken t = tokens[i];
 				if (channel == -1)
 				{
 					if (t.GetChannel() != Lexer.DefaultTokenChannel)
@@ -616,8 +616,8 @@ namespace Antlr4.Runtime
 			StringBuilder buf = new StringBuilder();
 			for (int i = start; i <= stop; i++)
 			{
-				Token t = tokens[i];
-				if (t.GetType() == Token.Eof)
+				IToken t = tokens[i];
+				if (t.GetType() == IToken.Eof)
 				{
 					break;
 				}
@@ -633,7 +633,7 @@ namespace Antlr4.Runtime
 		}
 
 		[NotNull]
-		public virtual string GetText(Token start, Token stop)
+		public virtual string GetText(IToken start, IToken stop)
 		{
 			if (start != null && stop != null)
 			{
diff --git a/Antlr4.Runtime/CommonToken.cs b/Antlr4.Runtime/CommonToken.cs
index 49569b0a5..51689d184 100644
--- a/Antlr4.Runtime/CommonToken.cs
+++ b/Antlr4.Runtime/CommonToken.cs
@@ -47,7 +47,7 @@ namespace Antlr4.Runtime
 
 		protected internal int channel = DefaultChannel;
 
-		protected internal Tuple<ITokenSource, CharStream> source;
+		protected internal Tuple<ITokenSource, ICharStream> source;
 
 		/// <summary>We need to be able to change the text once in a while.</summary>
 		/// <remarks>
@@ -74,8 +74,8 @@ namespace Antlr4.Runtime
 			this.type = type;
 		}
 
-		public CommonToken(Tuple<ITokenSource, CharStream> source, int type, int channel, 
-			int start, int stop)
+		public CommonToken(Tuple<ITokenSource, ICharStream> source, int type, int channel
+			, int start, int stop)
 		{
 			this.source = source;
 			this.type = type;
@@ -96,7 +96,7 @@ namespace Antlr4.Runtime
 			this.text = text;
 		}
 
-		public CommonToken(Token oldToken)
+		public CommonToken(IToken oldToken)
 		{
 			text = oldToken.GetText();
 			type = oldToken.GetType();
@@ -132,7 +132,7 @@ namespace Antlr4.Runtime
 			{
 				return text;
 			}
-			CharStream input = GetInputStream();
+			ICharStream input = GetInputStream();
 			if (input == null)
 			{
 				return null;
@@ -225,7 +225,7 @@ namespace Antlr4.Runtime
 			return source.GetItem1();
 		}
 
-		public virtual CharStream GetInputStream()
+		public virtual ICharStream GetInputStream()
 		{
 			return source.GetItem2();
 		}
diff --git a/Antlr4.Runtime/CommonTokenStream.cs b/Antlr4.Runtime/CommonTokenStream.cs
index 55f0e6941..17e7a3151 100644
--- a/Antlr4.Runtime/CommonTokenStream.cs
+++ b/Antlr4.Runtime/CommonTokenStream.cs
@@ -64,7 +64,7 @@ namespace Antlr4.Runtime
 		/// 	</summary>
 		/// <remarks>Skip tokens on any channel but this one; this is how we skip whitespace...
 		/// 	</remarks>
-		protected internal int channel = Token.DefaultChannel;
+		protected internal int channel = IToken.DefaultChannel;
 
 		public CommonTokenStream(ITokenSource tokenSource) : base(tokenSource)
 		{
@@ -81,7 +81,7 @@ namespace Antlr4.Runtime
 			return NextTokenOnChannel(i, channel);
 		}
 
-		protected internal override Token Lb(int k)
+		protected internal override IToken Lb(int k)
 		{
 			if (k == 0 || (p - k) < 0)
 			{
@@ -103,7 +103,7 @@ namespace Antlr4.Runtime
 			return tokens[i];
 		}
 
-		public override Token Lt(int k)
+		public override IToken Lt(int k)
 		{
 			//System.out.println("enter LT("+k+")");
 			LazyInit();
@@ -140,12 +140,12 @@ namespace Antlr4.Runtime
 			Fill();
 			for (int i = 0; i < tokens.Count; i++)
 			{
-				Token t = tokens[i];
+				IToken t = tokens[i];
 				if (t.GetChannel() == channel)
 				{
 					n++;
 				}
-				if (t.GetType() == Token.Eof)
+				if (t.GetType() == IToken.Eof)
 				{
 					break;
 				}
diff --git a/Antlr4.Runtime/DefaultErrorStrategy.cs b/Antlr4.Runtime/DefaultErrorStrategy.cs
index baa7b6752..5414b2cd5 100644
--- a/Antlr4.Runtime/DefaultErrorStrategy.cs
+++ b/Antlr4.Runtime/DefaultErrorStrategy.cs
@@ -196,7 +196,7 @@ namespace Antlr4.Runtime
 			ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
 			int la = tokens.La(1);
 			// try cheaper subset first; might get lucky. seems to shave a wee bit off
-			if (recognizer.GetATN().NextTokens(s).Contains(la) || la == Token.Eof)
+			if (recognizer.GetATN().NextTokens(s).Contains(la) || la == IToken.Eof)
 			{
 				return;
 			}
@@ -249,7 +249,7 @@ namespace Antlr4.Runtime
 			string input;
 			if (tokens != null)
 			{
-				if (e.GetStartToken().GetType() == Token.Eof)
+				if (e.GetStartToken().GetType() == IToken.Eof)
 				{
 					input = "<EOF>";
 				}
@@ -292,7 +292,7 @@ namespace Antlr4.Runtime
 			}
 			recognizer._syntaxErrors++;
 			BeginErrorCondition(recognizer);
-			Token t = recognizer.GetCurrentToken();
+			IToken t = recognizer.GetCurrentToken();
 			string tokenName = GetTokenErrorDisplay(t);
 			IntervalSet expecting = GetExpectedTokens(recognizer);
 			string msg = "extraneous input " + tokenName + " expecting " + expecting.ToString
@@ -308,7 +308,7 @@ namespace Antlr4.Runtime
 			}
 			recognizer._syntaxErrors++;
 			BeginErrorCondition(recognizer);
-			Token t = recognizer.GetCurrentToken();
+			IToken t = recognizer.GetCurrentToken();
 			IntervalSet expecting = GetExpectedTokens(recognizer);
 			string msg = "missing " + expecting.ToString(recognizer.GetTokenNames()) + " at "
 				 + GetTokenErrorDisplay(t);
@@ -340,10 +340,10 @@ namespace Antlr4.Runtime
 		/// reference in rule atom.  It can assume that you forgot the ')'.
 		/// </remarks>
 		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual Token RecoverInline(Parser recognizer)
+		public virtual IToken RecoverInline(Parser recognizer)
 		{
 			// SINGLE TOKEN DELETION
-			Token matchedSymbol = SingleTokenDeletion(recognizer);
+			IToken matchedSymbol = SingleTokenDeletion(recognizer);
 			if (matchedSymbol != null)
 			{
 				// we have deleted the extra token.
@@ -382,7 +382,7 @@ namespace Antlr4.Runtime
 			return false;
 		}
 
-		public virtual Token SingleTokenDeletion(Parser recognizer)
+		public virtual IToken SingleTokenDeletion(Parser recognizer)
 		{
 			int nextTokenType = ((ITokenStream)recognizer.GetInputStream()).La(2);
 			IntervalSet expecting = GetExpectedTokens(recognizer);
@@ -392,7 +392,7 @@ namespace Antlr4.Runtime
 				recognizer.Consume();
 				// simply delete extra token
 				// we want to return the token we're actually matching
-				Token matchedSymbol = recognizer.GetCurrentToken();
+				IToken matchedSymbol = recognizer.GetCurrentToken();
 				EndErrorCondition(recognizer);
 				// we know current token is correct
 				return matchedSymbol;
@@ -420,14 +420,14 @@ namespace Antlr4.Runtime
 		/// If you change what tokens must be created by the lexer,
 		/// override this method to create the appropriate tokens.
 		/// </remarks>
-		protected internal virtual Token GetMissingSymbol(Parser recognizer)
+		protected internal virtual IToken GetMissingSymbol(Parser recognizer)
 		{
-			Token currentSymbol = recognizer.GetCurrentToken();
+			IToken currentSymbol = recognizer.GetCurrentToken();
 			IntervalSet expecting = GetExpectedTokens(recognizer);
 			int expectedTokenType = expecting.GetMinElement();
 			// get any element
 			string tokenText;
-			if (expectedTokenType == Token.Eof)
+			if (expectedTokenType == IToken.Eof)
 			{
 				tokenText = "<missing EOF>";
 			}
@@ -435,9 +435,9 @@ namespace Antlr4.Runtime
 			{
 				tokenText = "<missing " + recognizer.GetTokenNames()[expectedTokenType] + ">";
 			}
-			Token current = currentSymbol;
-			Token lookback = ((ITokenStream)recognizer.GetInputStream()).Lt(-1);
-			if (current.GetType() == Token.Eof && lookback != null)
+			IToken current = currentSymbol;
+			IToken lookback = ((ITokenStream)recognizer.GetInputStream()).Lt(-1);
+			if (current.GetType() == IToken.Eof && lookback != null)
 			{
 				current = lookback;
 			}
@@ -445,12 +445,12 @@ namespace Antlr4.Runtime
 				), expectedTokenType, tokenText, current);
 		}
 
-		protected internal virtual Token ConstructToken(ITokenSource tokenSource, int expectedTokenType
-			, string tokenText, Token current)
+		protected internal virtual IToken ConstructToken(ITokenSource tokenSource, int expectedTokenType
+			, string tokenText, IToken current)
 		{
 			ITokenFactory factory = tokenSource.GetTokenFactory();
 			return factory.Create(Tuple.Create(tokenSource, current.GetTokenSource().GetInputStream
-				()), expectedTokenType, tokenText, Token.DefaultChannel, -1, -1, current.GetLine
+				()), expectedTokenType, tokenText, IToken.DefaultChannel, -1, -1, current.GetLine
 				(), current.GetCharPositionInLine());
 		}
 
@@ -473,7 +473,7 @@ namespace Antlr4.Runtime
 		/// your token objects because you don't have to go modify your lexer
 		/// so that it creates a new Java type.
 		/// </remarks>
-		public virtual string GetTokenErrorDisplay(Token t)
+		public virtual string GetTokenErrorDisplay(IToken t)
 		{
 			if (t == null)
 			{
@@ -482,7 +482,7 @@ namespace Antlr4.Runtime
 			string s = GetSymbolText(t);
 			if (s == null)
 			{
-				if (GetSymbolType(t) == Token.Eof)
+				if (GetSymbolType(t) == IToken.Eof)
 				{
 					s = "<EOF>";
 				}
@@ -494,12 +494,12 @@ namespace Antlr4.Runtime
 			return EscapeWSAndQuote(s);
 		}
 
-		protected internal virtual string GetSymbolText(Token symbol)
+		protected internal virtual string GetSymbolText(IToken symbol)
 		{
 			return symbol.GetText();
 		}
 
-		protected internal virtual int GetSymbolType(Token symbol)
+		protected internal virtual int GetSymbolType(IToken symbol)
 		{
 			return symbol.GetType();
 		}
@@ -527,7 +527,7 @@ namespace Antlr4.Runtime
 				recoverSet.AddAll(follow);
 				ctx = ctx.parent;
 			}
-			recoverSet.Remove(Token.Epsilon);
+			recoverSet.Remove(IToken.Epsilon);
 			//		System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames()));
 			return recoverSet;
 		}
@@ -537,7 +537,7 @@ namespace Antlr4.Runtime
 		{
 			//		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
 			int ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
-			while (ttype != Token.Eof && !set.Contains(ttype))
+			while (ttype != IToken.Eof && !set.Contains(ttype))
 			{
 				//System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
 				//			recognizer.getInputStream().consume();
diff --git a/Antlr4.Runtime/Dfa/AbstractEdgeMap.cs b/Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs
similarity index 100%
rename from Antlr4.Runtime/Dfa/AbstractEdgeMap.cs
rename to Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs
diff --git a/Antlr4.Runtime/Dfa/ArrayEdgeMap.cs b/Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs
similarity index 100%
rename from Antlr4.Runtime/Dfa/ArrayEdgeMap.cs
rename to Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs
diff --git a/Antlr4.Runtime/Dfa/DFA.cs b/Antlr4.Runtime/Dfa/DFA.cs
index 35cb3bcde..8335f0d43 100644
--- a/Antlr4.Runtime/Dfa/DFA.cs
+++ b/Antlr4.Runtime/Dfa/DFA.cs
@@ -43,12 +43,12 @@ namespace Antlr4.Runtime.Dfa
 		/// 	</see>
 		/// so we can get old state back
 		/// (
-		/// <see cref="Sharpen.Set{E}">Sharpen.Set&lt;E&gt;</see>
+		/// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
 		/// only allows you to see if it's there).
 		/// </remarks>
 		[NotNull]
-		public readonly ConcurrentMap<DFAState, DFAState> states = new ConcurrentHashMap<
-			DFAState, DFAState>();
+		public readonly IConcurrentMap<DFAState, DFAState> states = new ConcurrentHashMap
+			<DFAState, DFAState>();
 
 		[Nullable]
 		public readonly AtomicReference<DFAState> s0 = new AtomicReference<DFAState>();
@@ -68,8 +68,8 @@ namespace Antlr4.Runtime.Dfa
 		/// <summary>
 		/// Set of configs for a DFA state with at least one conflict? Mainly used as "return value"
 		/// from
-		/// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
-		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+		/// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
 		/// 	</see>
 		/// for retry.
 		/// </summary>
diff --git a/Antlr4.Runtime/Dfa/DFASerializer.cs b/Antlr4.Runtime/Dfa/DFASerializer.cs
index 813afe686..6324f1d86 100644
--- a/Antlr4.Runtime/Dfa/DFASerializer.cs
+++ b/Antlr4.Runtime/Dfa/DFASerializer.cs
@@ -81,7 +81,7 @@ namespace Antlr4.Runtime.Dfa
 			StringBuilder buf = new StringBuilder();
 			if (dfa.states != null)
 			{
-				IList<DFAState> states = new AList<DFAState>(dfa.states.Values);
+				IList<DFAState> states = new List<DFAState>(dfa.states.Values);
 				states.Sort(new _IComparer_85());
 				foreach (DFAState s in states)
 				{
diff --git a/Antlr4.Runtime/Dfa/EdgeMap.cs b/Antlr4.Runtime/Dfa/IEdgeMap`1.cs
similarity index 97%
rename from Antlr4.Runtime/Dfa/EdgeMap.cs
rename to Antlr4.Runtime/Dfa/IEdgeMap`1.cs
index 7931bc393..37a7689b1 100644
--- a/Antlr4.Runtime/Dfa/EdgeMap.cs
+++ b/Antlr4.Runtime/Dfa/IEdgeMap`1.cs
@@ -28,13 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System.Collections.Generic;
+using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
 using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
 	/// <author>Sam Harwell</author>
-	public interface EdgeMap<T>
+	public interface IEdgeMap<T>
 	{
 		int Size();
 
diff --git a/Antlr4.Runtime/Dfa/SingletonEdgeMap.cs b/Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs
similarity index 100%
rename from Antlr4.Runtime/Dfa/SingletonEdgeMap.cs
rename to Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs
diff --git a/Antlr4.Runtime/Dfa/SparseEdgeMap.cs b/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs
similarity index 98%
rename from Antlr4.Runtime/Dfa/SparseEdgeMap.cs
rename to Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs
index 1c55a4cc5..022589a14 100644
--- a/Antlr4.Runtime/Dfa/SparseEdgeMap.cs
+++ b/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs
@@ -52,7 +52,7 @@ namespace Antlr4.Runtime.Dfa
 			, maxIndex)
 		{
 			this.keys = new int[maxSparseSize];
-			this.values = new AList<T>(maxSparseSize);
+			this.values = new List<T>(maxSparseSize);
 		}
 
 		private SparseEdgeMap(Antlr4.Runtime.Dfa.SparseEdgeMap<T> map, int maxSparseSize)
@@ -63,7 +63,7 @@ namespace Antlr4.Runtime.Dfa
 				throw new ArgumentException();
 			}
 			keys = Arrays.CopyOf(map.keys, maxSparseSize);
-			values = new AList<T>(maxSparseSize);
+			values = new List<T>(maxSparseSize);
 			Sharpen.Collections.AddAll(values, map.values);
 		}
 
diff --git a/Antlr4.Runtime/ANTLRErrorListener.cs b/Antlr4.Runtime/IAntlrErrorListener`1.cs
similarity index 98%
rename from Antlr4.Runtime/ANTLRErrorListener.cs
rename to Antlr4.Runtime/IAntlrErrorListener`1.cs
index c73bf3bbb..414ec4d18 100644
--- a/Antlr4.Runtime/ANTLRErrorListener.cs
+++ b/Antlr4.Runtime/IAntlrErrorListener`1.cs
@@ -33,7 +33,7 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <summary>How to emit recognition errors</summary>
-	public interface ANTLRErrorListener<Symbol>
+	public interface IAntlrErrorListener<Symbol>
 	{
 		/// <summary>Upon syntax error, notify any interested parties.</summary>
 		/// <remarks>
diff --git a/Antlr4.Runtime/ANTLRErrorStrategy.cs b/Antlr4.Runtime/IAntlrErrorStrategy.cs
similarity index 98%
rename from Antlr4.Runtime/ANTLRErrorStrategy.cs
rename to Antlr4.Runtime/IAntlrErrorStrategy.cs
index 669a0030d..a8a9bd140 100644
--- a/Antlr4.Runtime/ANTLRErrorStrategy.cs
+++ b/Antlr4.Runtime/IAntlrErrorStrategy.cs
@@ -53,7 +53,7 @@ namespace Antlr4.Runtime
 	/// TODO: To bail out upon first error, simply rethrow e?
 	/// TODO: what to do about lexers
 	/// </remarks>
-	public interface ANTLRErrorStrategy
+	public interface IAntlrErrorStrategy
 	{
 		/// <summary>
 		/// When matching elements within alternative, use this method
@@ -75,7 +75,7 @@ namespace Antlr4.Runtime
 		/// token is. We use object, because it could be a tree node.
 		/// </remarks>
 		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		Token RecoverInline(Parser recognizer);
+		IToken RecoverInline(Parser recognizer);
 
 		/// <summary>
 		/// Resynchronize the parser by consuming tokens until we find one
diff --git a/Antlr4.Runtime/CharStream.cs b/Antlr4.Runtime/ICharStream.cs
similarity index 96%
rename from Antlr4.Runtime/CharStream.cs
rename to Antlr4.Runtime/ICharStream.cs
index 7f900c99e..58925ab91 100644
--- a/Antlr4.Runtime/CharStream.cs
+++ b/Antlr4.Runtime/ICharStream.cs
@@ -35,7 +35,7 @@ namespace Antlr4.Runtime
 {
 	/// <summary>A source of characters for an ANTLR lexer.</summary>
 	/// <remarks>A source of characters for an ANTLR lexer.</remarks>
-	public abstract class CharStream : IntStream
+	public abstract class ICharStream : IIntStream
 	{
 		/// <summary>
 		/// The minimum allowed value for a character in a
@@ -56,7 +56,7 @@ namespace Antlr4.Runtime
 		/// for special use within an implementing class.
 		/// For some implementations, the data buffers required for supporting the
 		/// marked ranges of
-		/// <see cref="IntStream">IntStream</see>
+		/// <see cref="IIntStream">IIntStream</see>
 		/// are stored as
 		/// <code>char[]</code>
 		/// instead
@@ -81,7 +81,7 @@ namespace Antlr4.Runtime
 		/// <code>interval</code>
 		/// lies entirely within a marked range. For more
 		/// information about marked ranges, see
-		/// <see cref="IntStream.Mark()">IntStream.Mark()</see>
+		/// <see cref="IIntStream.Mark()">IIntStream.Mark()</see>
 		/// .
 		/// </remarks>
 		/// <param name="interval">an interval within the stream</param>
diff --git a/Antlr4.Runtime/IntStream.cs b/Antlr4.Runtime/IIntStream.cs
similarity index 98%
rename from Antlr4.Runtime/IntStream.cs
rename to Antlr4.Runtime/IIntStream.cs
index c6bd005f5..c270304a7 100644
--- a/Antlr4.Runtime/IntStream.cs
+++ b/Antlr4.Runtime/IIntStream.cs
@@ -57,7 +57,7 @@ namespace Antlr4.Runtime
 	/// </li>
 	/// </ul>
 	/// </remarks>
-	public abstract class IntStream
+	public abstract class IIntStream
 	{
 		/// <summary>
 		/// The value returned by
@@ -207,7 +207,7 @@ namespace Antlr4.Runtime
 		/// which they were created).
 		/// <p/>
 		/// The behavior of this method is unspecified if no call to an
-		/// <see cref="IntStream">initializing method</see>
+		/// <see cref="IIntStream">initializing method</see>
 		/// has occurred after this stream was
 		/// constructed.
 		/// <p/>
@@ -278,7 +278,7 @@ namespace Antlr4.Runtime
 		/// .
 		/// <p/>
 		/// The behavior of this method is unspecified if no call to an
-		/// <see cref="IntStream">initializing method</see>
+		/// <see cref="IIntStream">initializing method</see>
 		/// has occurred after this stream was
 		/// constructed.
 		/// </summary>
@@ -318,7 +318,7 @@ namespace Antlr4.Runtime
 		/// <see cref="Mark()">Mark()</see>
 		/// . The behavior of this method is unspecified if no call to
 		/// an
-		/// <see cref="IntStream">initializing method</see>
+		/// <see cref="IIntStream">initializing method</see>
 		/// has occurred after this stream
 		/// was constructed.
 		/// </summary>
diff --git a/Antlr4.Runtime/ParserErrorListener.cs b/Antlr4.Runtime/IParserErrorListener.cs
similarity index 97%
rename from Antlr4.Runtime/ParserErrorListener.cs
rename to Antlr4.Runtime/IParserErrorListener.cs
index 5bf5c0dee..4cfcef675 100644
--- a/Antlr4.Runtime/ParserErrorListener.cs
+++ b/Antlr4.Runtime/IParserErrorListener.cs
@@ -35,7 +35,7 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <summary>How to emit recognition errors</summary>
-	public interface ParserErrorListener : IAntlrErrorListener<Token>
+	public interface IParserErrorListener : IAntlrErrorListener<IToken>
 	{
 		/// <summary>
 		/// Called when the parser detects a true ambiguity: an input sequence can be matched
diff --git a/Antlr4.Runtime/Token.cs b/Antlr4.Runtime/IToken.cs
similarity index 96%
rename from Antlr4.Runtime/Token.cs
rename to Antlr4.Runtime/IToken.cs
index 8141edaef..7e730fc74 100644
--- a/Antlr4.Runtime/Token.cs
+++ b/Antlr4.Runtime/IToken.cs
@@ -42,7 +42,7 @@ namespace Antlr4.Runtime
 	/// (so we can ignore tabs), token channel, index, and source from which
 	/// we obtained this token.
 	/// </remarks>
-	public abstract class Token
+	public abstract class IToken
 	{
 		public const int InvalidType = 0;
 
@@ -58,7 +58,7 @@ namespace Antlr4.Runtime
 
 		public const int MinUserTokenType = 1;
 
-		public const int Eof = IntStream.Eof;
+		public const int Eof = IIntStream.Eof;
 
 		/// <summary>
 		/// All tokens go to the parser (unless skip() is called in that rule)
@@ -143,9 +143,9 @@ namespace Antlr4.Runtime
 
 		/// <summary>
 		/// Gets the
-		/// <see cref="CharStream">CharStream</see>
+		/// <see cref="ICharStream">ICharStream</see>
 		/// from which this token was derived.
 		/// </summary>
-		public abstract CharStream GetInputStream();
+		public abstract ICharStream GetInputStream();
 	}
 }
diff --git a/Antlr4.Runtime/TokenFactory.cs b/Antlr4.Runtime/ITokenFactory.cs
similarity index 94%
rename from Antlr4.Runtime/TokenFactory.cs
rename to Antlr4.Runtime/ITokenFactory.cs
index 686986ac2..347ae7f51 100644
--- a/Antlr4.Runtime/TokenFactory.cs
+++ b/Antlr4.Runtime/ITokenFactory.cs
@@ -39,7 +39,7 @@ namespace Antlr4.Runtime
 	/// 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 TokenFactory
+	public interface ITokenFactory
 	{
 		/// <summary>
 		/// This is the method used to create tokens in the lexer and in the
@@ -50,10 +50,10 @@ namespace Antlr4.Runtime
 		/// 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>
-		Token Create<_T0>(Tuple<_T0> source, int type, string text, int channel, int start
+		IToken Create<_T0>(Tuple<_T0> source, int type, string text, int channel, int start
 			, int stop, int line, int charPositionInLine) where _T0:ITokenSource;
 
 		/// <summary>Generically useful</summary>
-		Token Create(int type, string text);
+		IToken Create(int type, string text);
 	}
 }
diff --git a/Antlr4.Runtime/TokenSource.cs b/Antlr4.Runtime/ITokenSource.cs
similarity index 98%
rename from Antlr4.Runtime/TokenSource.cs
rename to Antlr4.Runtime/ITokenSource.cs
index e3c0aaba8..aaf50bf07 100644
--- a/Antlr4.Runtime/TokenSource.cs
+++ b/Antlr4.Runtime/ITokenSource.cs
@@ -50,7 +50,7 @@ namespace Antlr4.Runtime
 	/// requested a token.  Keep lexing until you get a valid one.  Just report
 	/// errors and keep going, looking for a valid token.
 	/// </remarks>
-	public interface TokenSource
+	public interface ITokenSource
 	{
 		/// <summary>Return a Token object from your input stream (usually a CharStream).</summary>
 		/// <remarks>
@@ -58,7 +58,7 @@ namespace Antlr4.Runtime
 		/// 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.
 		/// </remarks>
-		Token NextToken();
+		IToken NextToken();
 
 		int GetLine();
 
@@ -74,7 +74,7 @@ namespace Antlr4.Runtime
 		/// implement but it's nice to know where a Token comes from if you have
 		/// include files etc... on the input.
 		/// </remarks>
-		CharStream GetInputStream();
+		ICharStream GetInputStream();
 
 		/// <summary>
 		/// Where are you getting tokens from? normally the implication will simply
diff --git a/Antlr4.Runtime/TokenStream.cs b/Antlr4.Runtime/ITokenStream.cs
similarity index 91%
rename from Antlr4.Runtime/TokenStream.cs
rename to Antlr4.Runtime/ITokenStream.cs
index 9c3f17381..1859f79f5 100644
--- a/Antlr4.Runtime/TokenStream.cs
+++ b/Antlr4.Runtime/ITokenStream.cs
@@ -35,39 +35,39 @@ namespace Antlr4.Runtime
 {
 	/// <summary>
 	/// An
-	/// <see cref="IntStream">IntStream</see>
+	/// <see cref="IIntStream">IIntStream</see>
 	/// whose symbols are
-	/// <see cref="Token">Token</see>
+	/// <see cref="IToken">IToken</see>
 	/// instances.
 	/// </summary>
-	public interface TokenStream : IntStream
+	public interface ITokenStream : IIntStream
 	{
 		/// <summary>
 		/// Get the
-		/// <see cref="Token">Token</see>
+		/// <see cref="IToken">IToken</see>
 		/// instance associated with the value returned by
-		/// <see cref="IntStream.La(int)">LA(k)</see>
+		/// <see cref="IIntStream.La(int)">LA(k)</see>
 		/// . This method has the same pre- and post-conditions as
-		/// <see cref="IntStream.La(int)">IntStream.La(int)</see>
+		/// <see cref="IIntStream.La(int)">IIntStream.La(int)</see>
 		/// . In addition, when the preconditions of this method
 		/// are met, the return value is non-null and the value of
 		/// <code>LT(k).getType()==LA(k)</code>
 		/// .
 		/// </summary>
-		/// <seealso cref="IntStream.La(int)">IntStream.La(int)</seealso>
+		/// <seealso cref="IIntStream.La(int)">IIntStream.La(int)</seealso>
 		[NotNull]
-		Token Lt(int k);
+		IToken Lt(int k);
 
 		/// <summary>
 		/// Gets the
-		/// <see cref="Token">Token</see>
+		/// <see cref="IToken">IToken</see>
 		/// at the specified
 		/// <code>index</code>
 		/// 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="IntStream.Seek(int)">IntStream.Seek(int)</see>
+		/// <see cref="IIntStream.Seek(int)">IIntStream.Seek(int)</see>
 		/// . If the behavior of
 		/// <code>seek(index)</code>
 		/// is
@@ -96,7 +96,7 @@ namespace Antlr4.Runtime
 		/// retrieving the token at the specified index
 		/// </exception>
 		[NotNull]
-		Token Get(int i);
+		IToken Get(int i);
 
 		/// <summary>
 		/// Gets the underlying
@@ -145,7 +145,7 @@ namespace Antlr4.Runtime
 		/// <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="IntStream.Size()">IntStream.Size()</see>
+		/// <see cref="IIntStream.Size()">IIntStream.Size()</see>
 		/// and
 		/// <see cref="GetText(Antlr4.Runtime.Misc.Interval)">GetText(Antlr4.Runtime.Misc.Interval)
 		/// 	</see>
@@ -213,7 +213,7 @@ namespace Antlr4.Runtime
 		/// token, the behavior is unspecified.
 		/// <p/>
 		/// For streams which ensure that the
-		/// <see cref="Token.GetTokenIndex()">Token.GetTokenIndex()</see>
+		/// <see cref="IToken.GetTokenIndex()">IToken.GetTokenIndex()</see>
 		/// 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
@@ -240,6 +240,6 @@ namespace Antlr4.Runtime
 		/// this method for the specified tokens
 		/// </exception>
 		[NotNull]
-		string GetText(Token start, Token stop);
+		string GetText(IToken start, IToken stop);
 	}
 }
diff --git a/Antlr4.Runtime/WritableToken.cs b/Antlr4.Runtime/IWritableToken.cs
similarity index 97%
rename from Antlr4.Runtime/WritableToken.cs
rename to Antlr4.Runtime/IWritableToken.cs
index 9d2acfc5b..2b02e218e 100644
--- a/Antlr4.Runtime/WritableToken.cs
+++ b/Antlr4.Runtime/IWritableToken.cs
@@ -32,7 +32,7 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public interface WritableToken : Token
+	public interface IWritableToken : IToken
 	{
 		void SetText(string text);
 
diff --git a/Antlr4.Runtime/Lexer.cs b/Antlr4.Runtime/Lexer.cs
index df5ffb39c..79c7565eb 100644
--- a/Antlr4.Runtime/Lexer.cs
+++ b/Antlr4.Runtime/Lexer.cs
@@ -52,17 +52,17 @@ namespace Antlr4.Runtime
 
 		public const int Skip = -3;
 
-		public const int DefaultTokenChannel = Token.DefaultChannel;
+		public const int DefaultTokenChannel = IToken.DefaultChannel;
 
-		public const int Hidden = Token.HiddenChannel;
+		public const int Hidden = IToken.HiddenChannel;
 
 		public const int MinCharValue = '\u0000';
 
 		public const int MaxCharValue = '\uFFFE';
 
-		public CharStream _input;
+		public ICharStream _input;
 
-		protected internal Tuple<ITokenSource, CharStream> _tokenFactorySourcePair;
+		protected internal Tuple<ITokenSource, ICharStream> _tokenFactorySourcePair;
 
 		/// <summary>How to create token objects</summary>
 		protected internal ITokenFactory _factory = CommonTokenFactory.Default;
@@ -77,7 +77,7 @@ namespace Antlr4.Runtime
 		/// something nonnull so that the auto token emit mechanism will not
 		/// emit another token.
 		/// </remarks>
-		public Token _token;
+		public IToken _token;
 
 		/// <summary>
 		/// What character index in the stream did the current token start at?
@@ -123,7 +123,7 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		public string _text;
 
-		public Lexer(CharStream input)
+		public Lexer(ICharStream input)
 		{
 			this._input = input;
 			this._tokenFactorySourcePair = Tuple.Create(this, input);
@@ -138,8 +138,8 @@ namespace Antlr4.Runtime
 			}
 			// rewind the input
 			_token = null;
-			_type = Token.InvalidType;
-			_channel = Token.DefaultChannel;
+			_type = IToken.InvalidType;
+			_channel = IToken.DefaultChannel;
 			_tokenStartCharIndex = -1;
 			_tokenStartCharPositionInLine = -1;
 			_tokenStartLine = -1;
@@ -158,7 +158,7 @@ namespace Antlr4.Runtime
 		/// Return a token from this source; i.e., match a token on the char
 		/// stream.
 		/// </remarks>
-		public virtual Token NextToken()
+		public virtual IToken NextToken()
 		{
 			if (_input == null)
 			{
@@ -178,14 +178,14 @@ namespace Antlr4.Runtime
 						return _token;
 					}
 					_token = null;
-					_channel = Token.DefaultChannel;
+					_channel = IToken.DefaultChannel;
 					_tokenStartCharIndex = _input.Index();
 					_tokenStartCharPositionInLine = GetInterpreter().GetCharPositionInLine();
 					_tokenStartLine = GetInterpreter().GetLine();
 					_text = null;
 					do
 					{
-						_type = Token.InvalidType;
+						_type = IToken.InvalidType;
 						//				System.out.println("nextToken line "+tokenStartLine+" at "+((char)input.LA(1))+
 						//								   " in mode "+mode+
 						//								   " at index "+input.index());
@@ -201,11 +201,11 @@ namespace Antlr4.Runtime
 							Recover(e);
 							ttype = Skip;
 						}
-						if (_input.La(1) == IntStream.Eof)
+						if (_input.La(1) == IIntStream.Eof)
 						{
 							_hitEOF = true;
 						}
-						if (_type == Token.InvalidType)
+						if (_type == IToken.InvalidType)
 						{
 							_type = ttype;
 						}
@@ -285,7 +285,7 @@ outer_break: ;
 		}
 
 		/// <summary>Set the char stream and reset the lexer</summary>
-		public virtual void SetInputStream(CharStream input)
+		public virtual void SetInputStream(ICharStream input)
 		{
 			this._input = null;
 			this._tokenFactorySourcePair = Tuple.Create(this, _input);
@@ -299,7 +299,7 @@ outer_break: ;
 			return _input.GetSourceName();
 		}
 
-		public override IntStream GetInputStream()
+		public override IIntStream GetInputStream()
 		{
 			return _input;
 		}
@@ -314,7 +314,7 @@ outer_break: ;
 		/// 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(Token token)
+		public virtual void Emit(IToken token)
 		{
 			//System.err.println("emit "+token);
 			this._token = token;
@@ -331,15 +331,15 @@ outer_break: ;
 		/// use that to set the token's text.  Override this method to emit
 		/// custom Token objects or provide a new factory.
 		/// </remarks>
-		public virtual Token Emit()
+		public virtual IToken Emit()
 		{
-			Token t = _factory.Create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex
+			IToken t = _factory.Create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex
 				, GetCharIndex() - 1, _tokenStartLine, _tokenStartCharPositionInLine);
 			Emit(t);
 			return t;
 		}
 
-		public virtual Token EmitEOF()
+		public virtual IToken EmitEOF()
 		{
 			int cpos = GetCharPositionInLine();
 			// The character position for EOF is one beyond the position of
@@ -349,7 +349,7 @@ outer_break: ;
 				int n = _token.GetStopIndex() - _token.GetStartIndex() + 1;
 				cpos = _token.GetCharPositionInLine() + n;
 			}
-			Token eof = _factory.Create(_tokenFactorySourcePair, Token.Eof, null, Token.DefaultChannel
+			IToken eof = _factory.Create(_tokenFactorySourcePair, IToken.Eof, null, IToken.DefaultChannel
 				, _input.Index(), _input.Index() - 1, GetLine(), cpos);
 			Emit(eof);
 			return eof;
@@ -413,12 +413,12 @@ outer_break: ;
 
 		/// <summary>Override if emitting multiple tokens.</summary>
 		/// <remarks>Override if emitting multiple tokens.</remarks>
-		public virtual Token GetToken()
+		public virtual IToken GetToken()
 		{
 			return _token;
 		}
 
-		public virtual void SetToken(Token _token)
+		public virtual void SetToken(IToken _token)
 		{
 			this._token = _token;
 		}
@@ -467,11 +467,11 @@ outer_break: ;
 		/// 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<Token> GetAllTokens()
+		public virtual IList<IToken> GetAllTokens()
 		{
-			IList<Token> tokens = new AList<Token>();
-			Token t = NextToken();
-			while (t.GetType() != Token.Eof)
+			IList<IToken> tokens = new List<IToken>();
+			IToken t = NextToken();
+			while (t.GetType() != IToken.Eof)
 			{
 				tokens.AddItem(t);
 				t = NextToken();
@@ -481,7 +481,7 @@ outer_break: ;
 
 		public virtual void Recover(LexerNoViableAltException e)
 		{
-			if (_input.La(1) != IntStream.Eof)
+			if (_input.La(1) != IIntStream.Eof)
 			{
 				// skip a char and try again
 				GetInterpreter().Consume(_input);
@@ -512,7 +512,7 @@ outer_break: ;
 			string s = (char)c.ToString();
 			switch (c)
 			{
-				case Token.Eof:
+				case IToken.Eof:
 				{
 					s = "<EOF>";
 					break;
diff --git a/Antlr4.Runtime/LexerNoViableAltException.cs b/Antlr4.Runtime/LexerNoViableAltException.cs
index 198c3ac2e..f329cbd2b 100644
--- a/Antlr4.Runtime/LexerNoViableAltException.cs
+++ b/Antlr4.Runtime/LexerNoViableAltException.cs
@@ -47,8 +47,8 @@ namespace Antlr4.Runtime
 		[Nullable]
 		private readonly ATNConfigSet deadEndConfigs;
 
-		public LexerNoViableAltException(Lexer lexer, CharStream input, int startIndex, ATNConfigSet
-			 deadEndConfigs) : base(lexer, input)
+		public LexerNoViableAltException(Lexer lexer, ICharStream input, int startIndex, 
+			ATNConfigSet deadEndConfigs) : base(lexer, input)
 		{
 			this.startIndex = startIndex;
 			this.deadEndConfigs = deadEndConfigs;
@@ -65,17 +65,17 @@ namespace Antlr4.Runtime
 			return deadEndConfigs;
 		}
 
-		public override IntStream GetInputStream()
+		public override IIntStream GetInputStream()
 		{
-			return (CharStream)base.GetInputStream();
+			return (ICharStream)base.GetInputStream();
 		}
 
 		public override string ToString()
 		{
 			string symbol = string.Empty;
-			if (startIndex >= 0 && startIndex < ((CharStream)GetInputStream()).Size())
+			if (startIndex >= 0 && startIndex < ((ICharStream)GetInputStream()).Size())
 			{
-				symbol = ((CharStream)GetInputStream()).GetText(Interval.Of(startIndex, startIndex
+				symbol = ((ICharStream)GetInputStream()).GetText(Interval.Of(startIndex, startIndex
 					));
 				symbol = Utils.EscapeWhitespace(symbol, false);
 			}
diff --git a/Antlr4.Runtime/Misc/AbstractEqualityComparator.cs b/Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs
similarity index 96%
rename from Antlr4.Runtime/Misc/AbstractEqualityComparator.cs
rename to Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs
index 006b7a59d..98b75cad8 100644
--- a/Antlr4.Runtime/Misc/AbstractEqualityComparator.cs
+++ b/Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs
@@ -41,7 +41,7 @@ namespace Antlr4.Runtime.Misc
 	/// use virtual- instead of interface-dispatch when calling comparator methods.
 	/// </remarks>
 	/// <author>Sam Harwell</author>
-	public abstract class AbstractEqualityComparator<T> : EqualityComparator<T>
+	public abstract class AbstractEqualityComparator<T> : IEqualityComparator<T>
 	{
 		public abstract bool Equals(T arg1, T arg2);
 
diff --git a/Antlr4.Runtime/Misc/Array2DHashSet.cs b/Antlr4.Runtime/Misc/Array2DHashSet`1.cs
similarity index 99%
rename from Antlr4.Runtime/Misc/Array2DHashSet.cs
rename to Antlr4.Runtime/Misc/Array2DHashSet`1.cs
index 75d52e40f..e278bc8a6 100644
--- a/Antlr4.Runtime/Misc/Array2DHashSet.cs
+++ b/Antlr4.Runtime/Misc/Array2DHashSet`1.cs
@@ -36,7 +36,7 @@ using Sharpen;
 namespace Antlr4.Runtime.Misc
 {
 	/// <summary>
-	/// <see cref="Sharpen.Set{E}">Sharpen.Set&lt;E&gt;</see>
+	/// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
 	/// implementation with closed hashing (open addressing).
 	/// </summary>
 	public class Array2DHashSet<T> : ICollection<T>
@@ -600,7 +600,7 @@ namespace Antlr4.Runtime.Misc
 		/// 	</see>
 		/// methods to ensure the arguments to
 		/// the
-		/// <see cref="EqualityComparator{T}">EqualityComparator&lt;T&gt;</see>
+		/// <see cref="IEqualityComparator{T}">IEqualityComparator&lt;T&gt;</see>
 		/// for the set always have the expected
 		/// types.
 		/// </summary>
diff --git a/Antlr4.Runtime/Misc/DoubleKeyMap.cs b/Antlr4.Runtime/Misc/DoubleKeyMap`3.cs
similarity index 100%
rename from Antlr4.Runtime/Misc/DoubleKeyMap.cs
rename to Antlr4.Runtime/Misc/DoubleKeyMap`3.cs
diff --git a/Antlr4.Runtime/Misc/FlexibleHashMap.cs b/Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
similarity index 99%
rename from Antlr4.Runtime/Misc/FlexibleHashMap.cs
rename to Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
index 706732a90..dc16b3237 100644
--- a/Antlr4.Runtime/Misc/FlexibleHashMap.cs
+++ b/Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
@@ -201,7 +201,7 @@ namespace Antlr4.Runtime.Misc
 		{
 			get
 			{
-				IList<V> a = new AList<V>(Count);
+				IList<V> a = new List<V>(Count);
 				foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
 				{
 					if (bucket == null)
diff --git a/Antlr4.Runtime/Misc/EqualityComparator.cs b/Antlr4.Runtime/Misc/IEqualityComparator`1.cs
similarity index 98%
rename from Antlr4.Runtime/Misc/EqualityComparator.cs
rename to Antlr4.Runtime/Misc/IEqualityComparator`1.cs
index 2e6262e44..9b6b58a7d 100644
--- a/Antlr4.Runtime/Misc/EqualityComparator.cs
+++ b/Antlr4.Runtime/Misc/IEqualityComparator`1.cs
@@ -42,7 +42,7 @@ namespace Antlr4.Runtime.Misc
 	/// comparisons without requiring changes to the object itself.
 	/// </summary>
 	/// <author>Sam Harwell</author>
-	public interface EqualityComparator<T>
+	public interface IEqualityComparator<T>
 	{
 		/// <summary>This method returns a hash code for the specified object.</summary>
 		/// <remarks>This method returns a hash code for the specified object.</remarks>
diff --git a/Antlr4.Runtime/Misc/Func0.cs b/Antlr4.Runtime/Misc/IFunc0`1.cs
similarity index 98%
rename from Antlr4.Runtime/Misc/Func0.cs
rename to Antlr4.Runtime/Misc/IFunc0`1.cs
index 82a100be6..3088e14c4 100644
--- a/Antlr4.Runtime/Misc/Func0.cs
+++ b/Antlr4.Runtime/Misc/IFunc0`1.cs
@@ -33,7 +33,7 @@ using Sharpen;
 namespace Antlr4.Runtime.Misc
 {
 	/// <author>Sam Harwell</author>
-	public interface Func0<Result>
+	public interface IFunc0<Result>
 	{
 		Result Eval();
 	}
diff --git a/Antlr4.Runtime/Misc/Func1.cs b/Antlr4.Runtime/Misc/IFunc1`2.cs
similarity index 97%
rename from Antlr4.Runtime/Misc/Func1.cs
rename to Antlr4.Runtime/Misc/IFunc1`2.cs
index 99cb27e3c..fa3b371c8 100644
--- a/Antlr4.Runtime/Misc/Func1.cs
+++ b/Antlr4.Runtime/Misc/IFunc1`2.cs
@@ -33,7 +33,7 @@ using Sharpen;
 namespace Antlr4.Runtime.Misc
 {
 	/// <author>Sam Harwell</author>
-	public interface Func1<T1, Result>
+	public interface IFunc1<T1, Result>
 	{
 		Result Eval(T1 arg1);
 	}
diff --git a/Antlr4.Runtime/Misc/IntSet.cs b/Antlr4.Runtime/Misc/IIntSet.cs
similarity index 98%
rename from Antlr4.Runtime/Misc/IntSet.cs
rename to Antlr4.Runtime/Misc/IIntSet.cs
index 602b6c068..2662fb147 100644
--- a/Antlr4.Runtime/Misc/IntSet.cs
+++ b/Antlr4.Runtime/Misc/IIntSet.cs
@@ -28,6 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using System.Collections.Generic;
+using Antlr4.Runtime.Misc;
 using Sharpen;
 
 namespace Antlr4.Runtime.Misc
@@ -35,7 +36,7 @@ namespace Antlr4.Runtime.Misc
 	/// <summary>A generic set of ints.</summary>
 	/// <remarks>A generic set of ints.</remarks>
 	/// <seealso cref="IntervalSet">IntervalSet</seealso>
-	public interface IntSet
+	public interface IIntSet
 	{
 		/// <summary>Add an element to the set</summary>
 		void Add(int el);
diff --git a/Antlr4.Runtime/Misc/Predicate.cs b/Antlr4.Runtime/Misc/IPredicate`1.cs
similarity index 98%
rename from Antlr4.Runtime/Misc/Predicate.cs
rename to Antlr4.Runtime/Misc/IPredicate`1.cs
index 6a326b57c..b2ee45710 100644
--- a/Antlr4.Runtime/Misc/Predicate.cs
+++ b/Antlr4.Runtime/Misc/IPredicate`1.cs
@@ -33,7 +33,7 @@ using Sharpen;
 namespace Antlr4.Runtime.Misc
 {
 	/// <author>Sam Harwell</author>
-	public interface Predicate<T>
+	public interface IPredicate<T>
 	{
 		bool Eval(T arg);
 	}
diff --git a/Antlr4.Runtime/Misc/IntervalSet.cs b/Antlr4.Runtime/Misc/IntervalSet.cs
index c68e545a1..b0e3961e5 100644
--- a/Antlr4.Runtime/Misc/IntervalSet.cs
+++ b/Antlr4.Runtime/Misc/IntervalSet.cs
@@ -81,12 +81,12 @@ namespace Antlr4.Runtime.Misc
 		{
 			if (els == null)
 			{
-				intervals = new AList<Interval>(2);
+				intervals = new List<Interval>(2);
 			}
 			else
 			{
 				// most sets are 1 or 2 elements
-				intervals = new AList<Interval>(els.Length);
+				intervals = new List<Interval>(els.Length);
 				foreach (int e in els)
 				{
 					Add(e);
@@ -163,7 +163,7 @@ namespace Antlr4.Runtime.Misc
 			}
 			// find position in list
 			// Use iterators as we modify list in place
-			for (ListIterator<Interval> iter = intervals.ListIterator(); iter.HasNext(); )
+			for (IListIterator<Interval> iter = intervals.ListIterator(); iter.HasNext(); )
 			{
 				Interval r = iter.Next();
 				if (addition.Equals(r))
@@ -483,14 +483,14 @@ namespace Antlr4.Runtime.Misc
 					return I.a;
 				}
 			}
-			return Token.InvalidType;
+			return IToken.InvalidType;
 		}
 
 		public virtual int GetMaxElement()
 		{
 			if (IsNil())
 			{
-				return Token.InvalidType;
+				return IToken.InvalidType;
 			}
 			Interval last = intervals[intervals.Count - 1];
 			return last.b;
@@ -501,7 +501,7 @@ namespace Antlr4.Runtime.Misc
 		{
 			if (IsNil())
 			{
-				return Token.InvalidType;
+				return IToken.InvalidType;
 			}
 			int n = intervals.Count;
 			for (int i = 0; i < n; i++)
@@ -517,7 +517,7 @@ namespace Antlr4.Runtime.Misc
 					}
 				}
 			}
-			return Token.InvalidType;
+			return IToken.InvalidType;
 		}
 
 		/// <summary>Return a list of Interval objects.</summary>
@@ -672,13 +672,13 @@ namespace Antlr4.Runtime.Misc
 
 		protected internal virtual string ElementName(string[] tokenNames, int a)
 		{
-			if (a == Token.Eof)
+			if (a == IToken.Eof)
 			{
 				return "<EOF>";
 			}
 			else
 			{
-				if (a == Token.Epsilon)
+				if (a == IToken.Epsilon)
 				{
 					return "<EPSILON>";
 				}
@@ -725,7 +725,7 @@ namespace Antlr4.Runtime.Misc
 
 		public virtual IList<int> ToList()
 		{
-			IList<int> values = new AList<int>();
+			IList<int> values = new List<int>();
 			int n = intervals.Count;
 			for (int i = 0; i < n; i++)
 			{
diff --git a/Antlr4.Runtime/Misc/MultiMap.cs b/Antlr4.Runtime/Misc/MultiMap`2.cs
similarity index 95%
rename from Antlr4.Runtime/Misc/MultiMap.cs
rename to Antlr4.Runtime/Misc/MultiMap`2.cs
index cdec395fc..fc0c9fae5 100644
--- a/Antlr4.Runtime/Misc/MultiMap.cs
+++ b/Antlr4.Runtime/Misc/MultiMap`2.cs
@@ -44,7 +44,7 @@ namespace Antlr4.Runtime.Misc
 			IList<V> elementsForKey = Get(key);
 			if (elementsForKey == null)
 			{
-				elementsForKey = new AList<V>();
+				elementsForKey = new List<V>();
 				base.Put(key, elementsForKey);
 			}
 			elementsForKey.AddItem(value);
@@ -52,7 +52,7 @@ namespace Antlr4.Runtime.Misc
 
 		public virtual IList<Tuple<K, V>> GetPairs()
 		{
-			IList<Tuple<K, V>> pairs = new AList<Tuple<K, V>>();
+			IList<Tuple<K, V>> pairs = new List<Tuple<K, V>>();
 			foreach (K key in Keys)
 			{
 				foreach (V value in Get(key))
diff --git a/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs b/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
index 080c77667..cd35f8632 100644
--- a/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
+++ b/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
@@ -34,7 +34,7 @@ namespace Antlr4.Runtime.Misc
 {
 	/// <summary>
 	/// This default implementation of
-	/// <see cref="EqualityComparator{T}">EqualityComparator&lt;T&gt;</see>
+	/// <see cref="IEqualityComparator{T}">IEqualityComparator&lt;T&gt;</see>
 	/// uses object equality
 	/// for comparisons by calling
 	/// <see cref="object.GetHashCode()">object.GetHashCode()</see>
diff --git a/Antlr4.Runtime/Misc/OrderedHashSet.cs b/Antlr4.Runtime/Misc/OrderedHashSet`1.cs
similarity index 97%
rename from Antlr4.Runtime/Misc/OrderedHashSet.cs
rename to Antlr4.Runtime/Misc/OrderedHashSet`1.cs
index eb0a1f16b..875941603 100644
--- a/Antlr4.Runtime/Misc/OrderedHashSet.cs
+++ b/Antlr4.Runtime/Misc/OrderedHashSet`1.cs
@@ -47,7 +47,7 @@ namespace Antlr4.Runtime.Misc
 		private const long serialVersionUID = 5281944403755906761L;
 
 		/// <summary>Track the elements as they are added to the set</summary>
-		protected internal AList<T> elements = new AList<T>();
+		protected internal List<T> elements = new List<T>();
 
 		public virtual T Get(int i)
 		{
@@ -147,7 +147,7 @@ namespace Antlr4.Runtime.Misc
 		{
 			OrderedHashSet<T> dup = (OrderedHashSet<T>)base.Clone();
 			// safe (result of clone)
-			dup.elements = new AList<T>(this.elements);
+			dup.elements = new List<T>(this.elements);
 			return dup;
 		}
 
diff --git a/Antlr4.Runtime/Misc/RuleDependencyChecker.cs b/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
index 938e403b3..87299fc9e 100644
--- a/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
+++ b/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
@@ -54,7 +54,7 @@ namespace Antlr4.Runtime.Misc
 			{
 				return;
 			}
-			IList<Type> typesToCheck = new AList<Type>();
+			IList<Type> typesToCheck = new List<Type>();
 			typesToCheck.AddItem(dependentClass);
 			Sharpen.Collections.AddAll(typesToCheck, dependentClass.GetDeclaredClasses());
 			foreach (Type clazz in typesToCheck)
@@ -63,7 +63,7 @@ namespace Antlr4.Runtime.Misc
 				{
 					continue;
 				}
-				IList<Tuple<RuleDependency, AnnotatedElement>> dependencies = GetDependencies(clazz
+				IList<Tuple<RuleDependency, IAnnotatedElement>> dependencies = GetDependencies(clazz
 					);
 				if (dependencies.IsEmpty())
 				{
@@ -89,13 +89,13 @@ namespace Antlr4.Runtime.Misc
 			}
 		}
 
-		private static void CheckDependencies<_T0>(IList<Tuple<RuleDependency, AnnotatedElement
+		private static void CheckDependencies<_T0>(IList<Tuple<RuleDependency, IAnnotatedElement
 			>> dependencies, Type<_T0> recognizerClass) where _T0:Recognizer<object, object>
 		{
 			string[] ruleNames = GetRuleNames(recognizerClass);
 			int[] ruleVersions = GetRuleVersions(recognizerClass, ruleNames);
 			StringBuilder incompatible = new StringBuilder();
-			foreach (Tuple<RuleDependency, AnnotatedElement> dependency in dependencies)
+			foreach (Tuple<RuleDependency, IAnnotatedElement> dependency in dependencies)
 			{
 				if (!recognizerClass.IsAssignableFrom(dependency.GetItem1().Recognizer()))
 				{
@@ -218,11 +218,11 @@ namespace Antlr4.Runtime.Misc
 			return new string[0];
 		}
 
-		public static IList<Tuple<RuleDependency, AnnotatedElement>> GetDependencies<_T0>
-			(Type<_T0> clazz)
+		public static IList<Tuple<RuleDependency, IAnnotatedElement>> GetDependencies<_T0
+			>(Type<_T0> clazz)
 		{
-			IList<Tuple<RuleDependency, AnnotatedElement>> result = new AList<Tuple<RuleDependency
-				, AnnotatedElement>>();
+			IList<Tuple<RuleDependency, IAnnotatedElement>> result = new List<Tuple<RuleDependency
+				, IAnnotatedElement>>();
 			IList<ElementType> supportedTarget = Arrays.AsList(typeof(RuleDependency).GetAnnotation
 				<Target>().Value());
 			foreach (ElementType target in supportedTarget)
@@ -298,8 +298,8 @@ namespace Antlr4.Runtime.Misc
 			return result;
 		}
 
-		private static void GetElementDependencies(AnnotatedElement annotatedElement, IList
-			<Tuple<RuleDependency, AnnotatedElement>> result)
+		private static void GetElementDependencies(IAnnotatedElement annotatedElement, IList
+			<Tuple<RuleDependency, IAnnotatedElement>> result)
 		{
 			RuleDependency dependency = annotatedElement.GetAnnotation<RuleDependency>();
 			if (dependency != null)
diff --git a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
index e75bf6e46..27269ac3a 100644
--- a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
+++ b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
@@ -59,32 +59,30 @@ namespace Antlr4.Runtime.Misc
 		{
 		}
 
-		public override bool Process<_T0>(ICollection<_T0> annotations, RoundEnvironment 
-			roundEnv)
+		public override bool Process<_T0>(ICollection<_T0> annotations, IRoundEnvironment
+			 roundEnv)
 		{
 			if (!CheckClassNameConstants())
 			{
 				return true;
 			}
-			IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> dependencies = GetDependencies
-				(roundEnv);
-			IDictionary<TypeMirror, IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element
-				>>> recognizerDependencies = new Dictionary<TypeMirror, IList<Tuple<RuleDependency
-				, Javax.Lang.Model.Element.Element>>>();
-			foreach (Tuple<RuleDependency, Javax.Lang.Model.Element.Element> dependency in dependencies)
+			IList<Tuple<RuleDependency, IElement>> dependencies = GetDependencies(roundEnv);
+			IDictionary<ITypeMirror, IList<Tuple<RuleDependency, IElement>>> recognizerDependencies
+				 = new Dictionary<ITypeMirror, IList<Tuple<RuleDependency, IElement>>>();
+			foreach (Tuple<RuleDependency, IElement> dependency in dependencies)
 			{
-				TypeMirror recognizerType = GetRecognizerType(dependency.GetItem1());
-				IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> list = recognizerDependencies
-					.Get(recognizerType);
+				ITypeMirror recognizerType = GetRecognizerType(dependency.GetItem1());
+				IList<Tuple<RuleDependency, IElement>> list = recognizerDependencies.Get(recognizerType
+					);
 				if (list == null)
 				{
-					list = new AList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>>();
+					list = new List<Tuple<RuleDependency, IElement>>();
 					recognizerDependencies.Put(recognizerType, list);
 				}
 				list.AddItem(dependency);
 			}
-			foreach (KeyValuePair<TypeMirror, IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element
-				>>> entry in recognizerDependencies.EntrySet())
+			foreach (KeyValuePair<ITypeMirror, IList<Tuple<RuleDependency, IElement>>> entry in 
+				recognizerDependencies.EntrySet())
 			{
 				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Note, string.Format("ANTLR 4: Validating %d dependencies on rules in %s."
 					, entry.Value.Count, entry.Key.ToString()));
@@ -117,13 +115,13 @@ namespace Antlr4.Runtime.Misc
 			return true;
 		}
 
-		private static TypeMirror GetRecognizerType(RuleDependency dependency)
+		private static ITypeMirror GetRecognizerType(RuleDependency dependency)
 		{
 			try
 			{
 				dependency.Recognizer();
 				string message = string.Format("Expected %s to get the %s.", typeof(MirroredTypeException
-					).Name, typeof(TypeMirror).Name);
+					).Name, typeof(ITypeMirror).Name);
 				throw new NotSupportedException(message);
 			}
 			catch (MirroredTypeException ex)
@@ -132,14 +130,14 @@ namespace Antlr4.Runtime.Misc
 			}
 		}
 
-		private void CheckDependencies(IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element
-			>> dependencies, TypeMirror recognizerType)
+		private void CheckDependencies(IList<Tuple<RuleDependency, IElement>> dependencies
+			, ITypeMirror recognizerType)
 		{
 			string[] ruleNames = GetRuleNames(recognizerType);
 			int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
 			RuleDependencyProcessor.RuleRelations relations = ExtractRuleRelations(recognizerType
 				);
-			foreach (Tuple<RuleDependency, Javax.Lang.Model.Element.Element> dependency in dependencies)
+			foreach (Tuple<RuleDependency, IElement> dependency in dependencies)
 			{
 				try
 				{
@@ -152,7 +150,7 @@ namespace Antlr4.Runtime.Misc
 					int effectiveRule = dependency.GetItem1().Rule();
 					if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
 					{
-						Tuple<AnnotationMirror, AnnotationValue> ruleReferenceElement = FindRuleDependencyProperty
+						Tuple<IAnnotationMirror, IAnnotationValue> ruleReferenceElement = FindRuleDependencyProperty
 							(dependency, RuleDependencyProcessor.RuleDependencyProperty.Rule);
 						string message = string.Format("Rule dependency on unknown rule %d@%d in %s", dependency
 							.GetItem1().Rule(), dependency.GetItem1().Version(), GetRecognizerType(dependency
@@ -243,7 +241,7 @@ namespace Antlr4.Runtime.Misc
 					int declaredVersion = dependency.GetItem1().Version();
 					if (declaredVersion > highestRequiredDependency)
 					{
-						Tuple<AnnotationMirror, AnnotationValue> versionElement = FindRuleDependencyProperty
+						Tuple<IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty
 							(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
 						string message = string.Format("Rule dependency version mismatch: %s has maximum dependency version %d (expected %d) in %s"
 							, ruleNames[dependency.GetItem1().Rule()], highestRequiredDependency, declaredVersion
@@ -272,14 +270,14 @@ namespace Antlr4.Runtime.Misc
 			(Dependents.Self, Dependents.Parents, Dependents.Children, Dependents.Ancestors, 
 			Dependents.Descendants);
 
-		private void ReportUnimplementedDependents(Tuple<RuleDependency, Javax.Lang.Model.Element.Element
-			> dependency, EnumSet<Dependents> dependents)
+		private void ReportUnimplementedDependents(Tuple<RuleDependency, IElement> dependency
+			, EnumSet<Dependents> dependents)
 		{
 			EnumSet<Dependents> unimplemented = dependents.Clone();
 			unimplemented.RemoveAll(ImplementedDependents);
 			if (!unimplemented.IsEmpty())
 			{
-				Tuple<AnnotationMirror, AnnotationValue> dependentsElement = FindRuleDependencyProperty
+				Tuple<IAnnotationMirror, IAnnotationValue> dependentsElement = FindRuleDependencyProperty
 					(dependency, RuleDependencyProcessor.RuleDependencyProperty.Dependents);
 				if (dependentsElement == null)
 				{
@@ -301,9 +299,8 @@ namespace Antlr4.Runtime.Misc
 			}
 		}
 
-		private int CheckDependencyVersion(Tuple<RuleDependency, Javax.Lang.Model.Element.Element
-			> dependency, string[] ruleNames, int[] ruleVersions, int relatedRule, string relation
-			)
+		private int CheckDependencyVersion(Tuple<RuleDependency, IElement> dependency, string
+			[] ruleNames, int[] ruleVersions, int relatedRule, string relation)
 		{
 			string ruleName = ruleNames[dependency.GetItem1().Rule()];
 			string path;
@@ -321,7 +318,7 @@ namespace Antlr4.Runtime.Misc
 			int actualVersion = ruleVersions[relatedRule];
 			if (actualVersion > declaredVersion)
 			{
-				Tuple<AnnotationMirror, AnnotationValue> versionElement = FindRuleDependencyProperty
+				Tuple<IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty
 					(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
 				string message = string.Format("Rule dependency version mismatch: %s has version %d (expected <= %d) in %s"
 					, path, actualVersion, declaredVersion, GetRecognizerType(dependency.GetItem1())
@@ -340,19 +337,18 @@ namespace Antlr4.Runtime.Misc
 			return actualVersion;
 		}
 
-		private int[] GetRuleVersions(TypeMirror recognizerClass, string[] ruleNames)
+		private int[] GetRuleVersions(ITypeMirror recognizerClass, string[] ruleNames)
 		{
 			int[] versions = new int[ruleNames.Length];
-			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
-				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
-				));
-			foreach (Javax.Lang.Model.Element.Element element in elements)
+			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
+			foreach (IElement element in elements)
 			{
 				if (element.GetKind() != ElementKind.Field)
 				{
 					continue;
 				}
-				VariableElement field = (VariableElement)element;
+				IVariableElement field = (IVariableElement)element;
 				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
 				object constantValue = field.GetConstantValue();
 				bool isInteger = constantValue is int;
@@ -379,7 +375,7 @@ namespace Antlr4.Runtime.Misc
 							// ignore left-factored pseudo-rules
 							continue;
 						}
-						ExecutableElement ruleMethod = GetRuleMethod(recognizerClass, name);
+						IExecutableElement ruleMethod = GetRuleMethod(recognizerClass, name);
 						if (ruleMethod == null)
 						{
 							string message = string.Format("Could not find rule method for rule '%s' in recognizer %s."
@@ -401,18 +397,18 @@ namespace Antlr4.Runtime.Misc
 			return versions;
 		}
 
-		private ExecutableElement GetRuleMethod(TypeMirror recognizerClass, string name)
+		private IExecutableElement GetRuleMethod(ITypeMirror recognizerClass, string name
+			)
 		{
-			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
-				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
-				));
-			foreach (Javax.Lang.Model.Element.Element element in elements)
+			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
+			foreach (IElement element in elements)
 			{
 				if (element.GetKind() != ElementKind.Method)
 				{
 					continue;
 				}
-				ExecutableElement method = (ExecutableElement)element;
+				IExecutableElement method = (IExecutableElement)element;
 				if (method.GetSimpleName().ContentEquals(name) && HasRuleVersionAnnotation(method
 					))
 				{
@@ -422,15 +418,15 @@ namespace Antlr4.Runtime.Misc
 			return null;
 		}
 
-		private bool HasRuleVersionAnnotation(ExecutableElement method)
+		private bool HasRuleVersionAnnotation(IExecutableElement method)
 		{
-			TypeElement ruleVersionAnnotationElement = processingEnv.GetElementUtils().GetTypeElement
+			ITypeElement ruleVersionAnnotationElement = processingEnv.GetElementUtils().GetTypeElement
 				(RuleVersionClassName);
 			if (ruleVersionAnnotationElement == null)
 			{
 				return false;
 			}
-			foreach (AnnotationMirror annotation in method.GetAnnotationMirrors())
+			foreach (IAnnotationMirror annotation in method.GetAnnotationMirrors())
 			{
 				if (processingEnv.GetTypeUtils().IsSameType(annotation.GetAnnotationType(), ruleVersionAnnotationElement
 					.AsType()))
@@ -441,19 +437,18 @@ namespace Antlr4.Runtime.Misc
 			return false;
 		}
 
-		private string[] GetRuleNames(TypeMirror recognizerClass)
+		private string[] GetRuleNames(ITypeMirror recognizerClass)
 		{
-			IList<string> result = new AList<string>();
-			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
-				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
-				));
-			foreach (Javax.Lang.Model.Element.Element element in elements)
+			IList<string> result = new List<string>();
+			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
+			foreach (IElement element in elements)
 			{
 				if (element.GetKind() != ElementKind.Field)
 				{
 					continue;
 				}
-				VariableElement field = (VariableElement)element;
+				IVariableElement field = (IVariableElement)element;
 				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
 				object constantValue = field.GetConstantValue();
 				bool isInteger = constantValue is int;
@@ -488,14 +483,14 @@ namespace Antlr4.Runtime.Misc
 			return Sharpen.Collections.ToArray(result, new string[result.Count]);
 		}
 
-		public static IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> GetDependencies
-			(RoundEnvironment roundEnv)
+		public static IList<Tuple<RuleDependency, IElement>> GetDependencies(IRoundEnvironment
+			 roundEnv)
 		{
-			IList<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>> result = new AList
-				<Tuple<RuleDependency, Javax.Lang.Model.Element.Element>>();
-			ICollection<Javax.Lang.Model.Element.Element> elements = roundEnv.GetElementsAnnotatedWith
-				(typeof(RuleDependency));
-			foreach (Javax.Lang.Model.Element.Element element in elements)
+			IList<Tuple<RuleDependency, IElement>> result = new List<Tuple<RuleDependency, IElement
+				>>();
+			ICollection<IElement> elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependency
+				));
+			foreach (IElement element in elements)
 			{
 				RuleDependency dependency = element.GetAnnotation<RuleDependency>();
 				if (dependency == null)
@@ -505,7 +500,7 @@ namespace Antlr4.Runtime.Misc
 				result.AddItem(Tuple.Create(dependency, element));
 			}
 			elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependencies));
-			foreach (Javax.Lang.Model.Element.Element element_1 in elements)
+			foreach (IElement element_1 in elements)
 			{
 				RuleDependencies dependencies = element_1.GetAnnotation<RuleDependencies>();
 				if (dependencies == null || dependencies.Value() == null)
@@ -529,21 +524,21 @@ namespace Antlr4.Runtime.Misc
 		}
 
 		[Nullable]
-		private Tuple<AnnotationMirror, AnnotationValue> FindRuleDependencyProperty(Tuple
-			<RuleDependency, Javax.Lang.Model.Element.Element> dependency, RuleDependencyProcessor.RuleDependencyProperty
+		private Tuple<IAnnotationMirror, IAnnotationValue> FindRuleDependencyProperty(Tuple
+			<RuleDependency, IElement> dependency, RuleDependencyProcessor.RuleDependencyProperty
 			 property)
 		{
-			TypeElement ruleDependencyTypeElement = processingEnv.GetElementUtils().GetTypeElement
+			ITypeElement ruleDependencyTypeElement = processingEnv.GetElementUtils().GetTypeElement
 				(RuleDependencyClassName);
-			TypeElement ruleDependenciesTypeElement = processingEnv.GetElementUtils().GetTypeElement
+			ITypeElement ruleDependenciesTypeElement = processingEnv.GetElementUtils().GetTypeElement
 				(RuleDependenciesClassName);
-			IList<AnnotationMirror> mirrors = dependency.GetItem2().GetAnnotationMirrors();
-			foreach (AnnotationMirror annotationMirror in mirrors)
+			IList<IAnnotationMirror> mirrors = dependency.GetItem2().GetAnnotationMirrors();
+			foreach (IAnnotationMirror annotationMirror in mirrors)
 			{
 				if (processingEnv.GetTypeUtils().IsSameType(ruleDependencyTypeElement.AsType(), annotationMirror
 					.GetAnnotationType()))
 				{
-					AnnotationValue element = FindRuleDependencyProperty(dependency, annotationMirror
+					IAnnotationValue element = FindRuleDependencyProperty(dependency, annotationMirror
 						, property);
 					if (element != null)
 					{
@@ -555,14 +550,14 @@ namespace Antlr4.Runtime.Misc
 					if (processingEnv.GetTypeUtils().IsSameType(ruleDependenciesTypeElement.AsType(), 
 						annotationMirror.GetAnnotationType()))
 					{
-						IDictionary<ExecutableElement, AnnotationValue> values = annotationMirror.GetElementValues
+						IDictionary<IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues
 							();
-						foreach (KeyValuePair<ExecutableElement, AnnotationValue> value in values.EntrySet
+						foreach (KeyValuePair<IExecutableElement, IAnnotationValue> value in values.EntrySet
 							())
 						{
 							if ("value()".Equals(value.Key.ToString()))
 							{
-								AnnotationValue annotationValue = value.Value;
+								IAnnotationValue annotationValue = value.Value;
 								if (!(annotationValue.GetValue() is IList))
 								{
 									processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected array of RuleDependency annotations for annotation property 'value()'."
@@ -572,17 +567,17 @@ namespace Antlr4.Runtime.Misc
 								IList<object> annotationValueList = (IList<object>)annotationValue.GetValue();
 								foreach (object obj in annotationValueList)
 								{
-									if (!(obj is AnnotationMirror))
+									if (!(obj is IAnnotationMirror))
 									{
 										processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected RuleDependency annotation mirror for element of property 'value()'."
 											, dependency.GetItem2(), annotationMirror, annotationValue);
 										break;
 									}
-									AnnotationValue element = FindRuleDependencyProperty(dependency, (AnnotationMirror
+									IAnnotationValue element = FindRuleDependencyProperty(dependency, (IAnnotationMirror
 										)obj, property);
 									if (element != null)
 									{
-										return Tuple.Create((AnnotationMirror)obj, element);
+										return Tuple.Create((IAnnotationMirror)obj, element);
 									}
 								}
 							}
@@ -599,20 +594,20 @@ namespace Antlr4.Runtime.Misc
 		}
 
 		[Nullable]
-		private AnnotationValue FindRuleDependencyProperty(Tuple<RuleDependency, Javax.Lang.Model.Element.Element
-			> dependency, AnnotationMirror annotationMirror, RuleDependencyProcessor.RuleDependencyProperty
+		private IAnnotationValue FindRuleDependencyProperty(Tuple<RuleDependency, IElement
+			> dependency, IAnnotationMirror annotationMirror, RuleDependencyProcessor.RuleDependencyProperty
 			 property)
 		{
-			AnnotationValue recognizerValue = null;
-			AnnotationValue ruleValue = null;
-			AnnotationValue versionValue = null;
-			AnnotationValue dependentsValue = null;
-			IDictionary<ExecutableElement, AnnotationValue> values = annotationMirror.GetElementValues
+			IAnnotationValue recognizerValue = null;
+			IAnnotationValue ruleValue = null;
+			IAnnotationValue versionValue = null;
+			IAnnotationValue dependentsValue = null;
+			IDictionary<IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues
 				();
-			foreach (KeyValuePair<ExecutableElement, AnnotationValue> value in values.EntrySet
+			foreach (KeyValuePair<IExecutableElement, IAnnotationValue> value in values.EntrySet
 				())
 			{
-				AnnotationValue annotationValue = value.Value;
+				IAnnotationValue annotationValue = value.Value;
 				if ("rule()".Equals(value.Key.ToString()))
 				{
 					ruleValue = annotationValue;
@@ -633,14 +628,14 @@ namespace Antlr4.Runtime.Misc
 					if ("recognizer()".Equals(value.Key.ToString()))
 					{
 						recognizerValue = annotationValue;
-						if (!(annotationValue.GetValue() is TypeMirror))
+						if (!(annotationValue.GetValue() is ITypeMirror))
 						{
 							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected Class constant for annotation property 'recognizer()'."
 								, dependency.GetItem2(), annotationMirror, annotationValue);
 							return null;
 						}
-						TypeMirror annotationRecognizer = (TypeMirror)annotationValue.GetValue();
-						TypeMirror expectedRecognizer = GetRecognizerType(dependency.GetItem1());
+						ITypeMirror annotationRecognizer = (ITypeMirror)annotationValue.GetValue();
+						ITypeMirror expectedRecognizer = GetRecognizerType(dependency.GetItem1());
 						if (!processingEnv.GetTypeUtils().IsSameType(expectedRecognizer, annotationRecognizer
 							))
 						{
@@ -728,7 +723,7 @@ namespace Antlr4.Runtime.Misc
 			return null;
 		}
 
-		private RuleDependencyProcessor.RuleRelations ExtractRuleRelations(TypeMirror recognizer
+		private RuleDependencyProcessor.RuleRelations ExtractRuleRelations(ITypeMirror recognizer
 			)
 		{
 			string serializedATN = GetSerializedATN(recognizer);
@@ -758,18 +753,17 @@ namespace Antlr4.Runtime.Misc
 			return relations;
 		}
 
-		private string GetSerializedATN(TypeMirror recognizerClass)
+		private string GetSerializedATN(ITypeMirror recognizerClass)
 		{
-			IList<Javax.Lang.Model.Element.Element> elements = processingEnv.GetElementUtils(
-				).GetAllMembers((TypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass
-				));
-			foreach (Javax.Lang.Model.Element.Element element in elements)
+			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
+			foreach (IElement element in elements)
 			{
 				if (element.GetKind() != ElementKind.Field)
 				{
 					continue;
 				}
-				VariableElement field = (VariableElement)element;
+				IVariableElement field = (IVariableElement)element;
 				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
 				object constantValue = field.GetConstantValue();
 				bool isString = constantValue is string;
diff --git a/Antlr4.Runtime/Misc/TestRig.cs b/Antlr4.Runtime/Misc/TestRig.cs
index b4cfc0969..05c883d61 100644
--- a/Antlr4.Runtime/Misc/TestRig.cs
+++ b/Antlr4.Runtime/Misc/TestRig.cs
@@ -61,7 +61,7 @@ namespace Antlr4.Runtime.Misc
 
 		protected internal string startRuleName;
 
-		protected internal readonly IList<string> inputFiles = new AList<string>();
+		protected internal readonly IList<string> inputFiles = new List<string>();
 
 		protected internal bool printTree = false;
 
@@ -202,8 +202,8 @@ namespace Antlr4.Runtime.Misc
 					return;
 				}
 			}
-			Constructor<Lexer> lexerCtor = lexerClass.GetConstructor(typeof(CharStream));
-			Lexer lexer = lexerCtor.NewInstance((CharStream)null);
+			Constructor<Lexer> lexerCtor = lexerClass.GetConstructor(typeof(ICharStream));
+			Lexer lexer = lexerCtor.NewInstance((ICharStream)null);
 			Type parserClass = null;
 			Parser parser = null;
 			if (!startRuleName.Equals(LexerStartRuleName))
@@ -265,7 +265,7 @@ namespace Antlr4.Runtime.Misc
 		{
 			try
 			{
-				ANTLRInputStream input = new ANTLRInputStream(r);
+				AntlrInputStream input = new AntlrInputStream(r);
 				lexer.SetInputStream(input);
 				CommonTokenStream tokens = new CommonTokenStream(lexer);
 				tokens.Fill();
diff --git a/Antlr4.Runtime/Misc/Tuple.cs b/Antlr4.Runtime/Misc/Tuple.cs
index 41186b700..4dcc9f258 100644
--- a/Antlr4.Runtime/Misc/Tuple.cs
+++ b/Antlr4.Runtime/Misc/Tuple.cs
@@ -27,67 +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.
  */
-using System;
 using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
 	/// <author>Sam Harwell</author>
-	public class Tuple<T1, T2, T3>
+	public sealed class Tuple
 	{
-		private readonly T1 item1;
-
-		private readonly T2 item2;
-
-		private readonly T3 item3;
-
-		public Tuple(T1 item1, T2 item2, T3 item3)
+		public static System.Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
 		{
-			this.item1 = item1;
-			this.item2 = item2;
-			this.item3 = item3;
+			return new System.Tuple<T1, T2>(item1, item2);
 		}
 
-		public T1 GetItem1()
+		public static System.Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 
+			item3)
 		{
-			return item1;
+			return new System.Tuple<T1, T2, T3>(item1, item2, item3);
 		}
 
-		public T2 GetItem2()
+		internal static bool Equals(object x, object y)
 		{
-			return item2;
+			return x == y || (x != null && x.Equals(y));
 		}
 
-		public T3 GetItem3()
+		public Tuple()
 		{
-			return item3;
-		}
-
-		public override bool Equals(object obj)
-		{
-			if (obj == this)
-			{
-				return true;
-			}
-			else
-			{
-				if (!(obj is Tuple<object, object, object>))
-				{
-					return false;
-				}
-			}
-			Tuple<object, object, object> other = (Tuple<object, object, object>)obj;
-			return Tuple.Equals(this.item1, other.item1) && Tuple.Equals(this.item2, other.item2
-				) && Tuple.Equals(this.item3, other.item3);
-		}
-
-		public override int GetHashCode()
-		{
-			int hash = 5;
-			hash = 79 * hash + (this.item1 != null ? this.item1.GetHashCode() : 0);
-			hash = 79 * hash + (this.item2 != null ? this.item2.GetHashCode() : 0);
-			hash = 79 * hash + (this.item3 != null ? this.item3.GetHashCode() : 0);
-			return hash;
 		}
+		// static utility class
 	}
 }
diff --git a/Antlr4.Runtime/Misc/Tuple`2.cs b/Antlr4.Runtime/Misc/Tuple`2.cs
new file mode 100644
index 000000000..34e647d2b
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Tuple`2.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 System;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public class Tuple<T1, T2>
+	{
+		private readonly T1 item1;
+
+		private readonly T2 item2;
+
+		public Tuple(T1 item1, T2 item2)
+		{
+			this.item1 = item1;
+			this.item2 = item2;
+		}
+
+		public T1 GetItem1()
+		{
+			return item1;
+		}
+
+		public T2 GetItem2()
+		{
+			return item2;
+		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == this)
+			{
+				return true;
+			}
+			else
+			{
+				if (!(obj is Tuple<object, object>))
+				{
+					return false;
+				}
+			}
+			Tuple<object, object> other = (Tuple<object, object>)obj;
+			return Tuple.Equals(this.item1, other.item1) && Tuple.Equals(this.item2, other.item2
+				);
+		}
+
+		public override int GetHashCode()
+		{
+			int hash = 5;
+			hash = 79 * hash + (this.item1 != null ? this.item1.GetHashCode() : 0);
+			hash = 79 * hash + (this.item2 != null ? this.item2.GetHashCode() : 0);
+			return hash;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Tuple`3.cs b/Antlr4.Runtime/Misc/Tuple`3.cs
new file mode 100644
index 000000000..41186b700
--- /dev/null
+++ b/Antlr4.Runtime/Misc/Tuple`3.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;
+using Sharpen;
+
+namespace Antlr4.Runtime.Misc
+{
+	/// <author>Sam Harwell</author>
+	public class Tuple<T1, T2, T3>
+	{
+		private readonly T1 item1;
+
+		private readonly T2 item2;
+
+		private readonly T3 item3;
+
+		public Tuple(T1 item1, T2 item2, T3 item3)
+		{
+			this.item1 = item1;
+			this.item2 = item2;
+			this.item3 = item3;
+		}
+
+		public T1 GetItem1()
+		{
+			return item1;
+		}
+
+		public T2 GetItem2()
+		{
+			return item2;
+		}
+
+		public T3 GetItem3()
+		{
+			return item3;
+		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == this)
+			{
+				return true;
+			}
+			else
+			{
+				if (!(obj is Tuple<object, object, object>))
+				{
+					return false;
+				}
+			}
+			Tuple<object, object, object> other = (Tuple<object, object, object>)obj;
+			return Tuple.Equals(this.item1, other.item1) && Tuple.Equals(this.item2, other.item2
+				) && Tuple.Equals(this.item3, other.item3);
+		}
+
+		public override int GetHashCode()
+		{
+			int hash = 5;
+			hash = 79 * hash + (this.item1 != null ? this.item1.GetHashCode() : 0);
+			hash = 79 * hash + (this.item2 != null ? this.item2.GetHashCode() : 0);
+			hash = 79 * hash + (this.item3 != null ? this.item3.GetHashCode() : 0);
+			return hash;
+		}
+	}
+}
diff --git a/Antlr4.Runtime/Misc/Utils.cs b/Antlr4.Runtime/Misc/Utils.cs
index dd210b008..b9d32a2e4 100644
--- a/Antlr4.Runtime/Misc/Utils.cs
+++ b/Antlr4.Runtime/Misc/Utils.cs
@@ -154,7 +154,7 @@ namespace Antlr4.Runtime.Misc
 			w.Close();
 		}
 
-		public static void RemoveAll<T, _T1>(IList<T> list, Predicate<_T1> predicate)
+		public static void RemoveAll<T, _T1>(IList<T> list, IPredicate<_T1> predicate)
 		{
 			int j = 0;
 			for (int i = 0; i < list.Count; i++)
@@ -175,7 +175,7 @@ namespace Antlr4.Runtime.Misc
 			}
 		}
 
-		public static void RemoveAll<T, _T1>(IEnumerable<T> iterable, Predicate<_T1> predicate
+		public static void RemoveAll<T, _T1>(IEnumerable<T> iterable, IPredicate<_T1> predicate
 			)
 		{
 			if (iterable is IList<object>)
diff --git a/Antlr4.Runtime/NoViableAltException.cs b/Antlr4.Runtime/NoViableAltException.cs
index 4bc389728..828809554 100644
--- a/Antlr4.Runtime/NoViableAltException.cs
+++ b/Antlr4.Runtime/NoViableAltException.cs
@@ -65,7 +65,7 @@ namespace Antlr4.Runtime
 		/// buffer all of the tokens but later we might not have access to those.)
 		/// </remarks>
 		[NotNull]
-		private readonly Token startToken;
+		private readonly IToken startToken;
 
 		public NoViableAltException(Parser recognizer) : this(recognizer, ((ITokenStream)
 			recognizer.GetInputStream()), recognizer.GetCurrentToken(), recognizer.GetCurrentToken
@@ -73,8 +73,8 @@ namespace Antlr4.Runtime
 		{
 		}
 
-		public NoViableAltException(Recognizer<Token, object> recognizer, ITokenStream input
-			, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext
+		public NoViableAltException(Recognizer<IToken, object> recognizer, ITokenStream input
+			, IToken startToken, IToken offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext
 			 ctx) : base(recognizer, input, ctx)
 		{
 			// LL(1) error
@@ -83,7 +83,7 @@ namespace Antlr4.Runtime
 			this.SetOffendingToken(offendingToken);
 		}
 
-		public virtual Token GetStartToken()
+		public virtual IToken GetStartToken()
 		{
 			return startToken;
 		}
diff --git a/Antlr4.Runtime/Parser.cs b/Antlr4.Runtime/Parser.cs
index 1c6d9ddb0..e447ee8bc 100644
--- a/Antlr4.Runtime/Parser.cs
+++ b/Antlr4.Runtime/Parser.cs
@@ -33,6 +33,7 @@ using Antlr4.Runtime;
 using Antlr4.Runtime.Atn;
 using Antlr4.Runtime.Dfa;
 using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime
@@ -41,7 +42,7 @@ namespace Antlr4.Runtime
 	/// 	</summary>
 	/// <remarks>This is all the parsing support code essentially; most of it is error recovery stuff.
 	/// 	</remarks>
-	public abstract class Parser : Recognizer<Token, ParserATNSimulator>
+	public abstract class Parser : Recognizer<IToken, ParserATNSimulator>
 	{
 		public class TraceListener : IParseTreeListener
 		{
@@ -64,7 +65,7 @@ namespace Antlr4.Runtime
 			public virtual void VisitTerminal(ITerminalNode node)
 			{
 				ParserRuleContext parent = (ParserRuleContext)node.GetParent().GetRuleContext();
-				Token token = node.GetSymbol();
+				IToken token = node.GetSymbol();
 				System.Console.Out.WriteLine("consume " + token + " rule " + this._enclosing.GetRuleNames
 					()[parent.GetRuleIndex()] + " alt=" + parent.altNum);
 			}
@@ -98,7 +99,7 @@ namespace Antlr4.Runtime
 			{
 				if (ctx.children is ArrayList)
 				{
-					((AList<object>)ctx.children).TrimToSize();
+					((List<object>)ctx.children).TrimToSize();
 				}
 			}
 		}
@@ -178,9 +179,9 @@ namespace Antlr4.Runtime
 		/// that fails, throw MismatchedTokenException.
 		/// </remarks>
 		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual Token Match(int ttype)
+		public virtual IToken Match(int ttype)
 		{
-			Token t = GetCurrentToken();
+			IToken t = GetCurrentToken();
 			if (t.GetType() == ttype)
 			{
 				_errHandler.EndErrorCondition(this);
@@ -200,9 +201,9 @@ namespace Antlr4.Runtime
 		}
 
 		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual Token MatchWildcard()
+		public virtual IToken MatchWildcard()
 		{
-			Token t = GetCurrentToken();
+			IToken t = GetCurrentToken();
 			if (t.GetType() > 0)
 			{
 				_errHandler.EndErrorCondition(this);
@@ -336,7 +337,7 @@ namespace Antlr4.Runtime
 			}
 			if (_parseListeners == null)
 			{
-				_parseListeners = new AList<IParseTreeListener>();
+				_parseListeners = new List<IParseTreeListener>();
 			}
 			this._parseListeners.AddItem(listener);
 		}
@@ -425,7 +426,7 @@ namespace Antlr4.Runtime
 			this._errHandler = handler;
 		}
 
-		public override IntStream GetInputStream()
+		public override IIntStream GetInputStream()
 		{
 			return _input;
 		}
@@ -446,7 +447,7 @@ namespace Antlr4.Runtime
 		/// 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 Token GetCurrentToken()
+		public virtual IToken GetCurrentToken()
 		{
 			return _input.Lt(1);
 		}
@@ -456,7 +457,7 @@ namespace Antlr4.Runtime
 			NotifyErrorListeners(GetCurrentToken(), msg, null);
 		}
 
-		public virtual void NotifyErrorListeners(Token offendingToken, string msg, RecognitionException
+		public virtual void NotifyErrorListeners(IToken offendingToken, string msg, RecognitionException
 			 e)
 		{
 			int line = -1;
@@ -466,7 +467,7 @@ namespace Antlr4.Runtime
 				line = offendingToken.GetLine();
 				charPositionInLine = offendingToken.GetCharPositionInLine();
 			}
-			IAntlrErrorListener<Token> listener = ((IParserErrorListener)GetErrorListenerDispatch
+			IAntlrErrorListener<IToken> listener = ((IParserErrorListener)GetErrorListenerDispatch
 				());
 			listener.SyntaxError(this, offendingToken, line, charPositionInLine, msg, e);
 		}
@@ -482,9 +483,9 @@ namespace Antlr4.Runtime
 		/// would also be added as a child to the current context (node).
 		/// Trigger listener events if there's a listener.
 		/// </remarks>
-		public virtual Token Consume()
+		public virtual IToken Consume()
 		{
-			Token o = GetCurrentToken();
+			IToken o = GetCurrentToken();
 			if (o.GetType() != Eof)
 			{
 				((ITokenStream)GetInputStream()).Consume();
@@ -690,7 +691,7 @@ namespace Antlr4.Runtime
 			return precedence >= _precedenceStack.Peek();
 		}
 
-		public override IAntlrErrorListener<Token> GetErrorListenerDispatch()
+		public override IAntlrErrorListener<IToken> GetErrorListenerDispatch()
 		{
 			return new ProxyParserErrorListener(GetErrorListeners());
 		}
@@ -713,12 +714,12 @@ namespace Antlr4.Runtime
 				return true;
 			}
 			//        System.out.println("following "+s+"="+following);
-			if (!following.Contains(Token.Epsilon))
+			if (!following.Contains(IToken.Epsilon))
 			{
 				return false;
 			}
-			while (ctx != null && ctx.invokingState >= 0 && following.Contains(Token.Epsilon)
-				)
+			while (ctx != null && ctx.invokingState >= 0 && following.Contains(IToken.Epsilon
+				))
 			{
 				ATNState invokingState = atn.states[ctx.invokingState];
 				RuleTransition rt = (RuleTransition)invokingState.Transition(0);
@@ -729,7 +730,7 @@ namespace Antlr4.Runtime
 				}
 				ctx = (ParserRuleContext)ctx.parent;
 			}
-			if (following.Contains(Token.Epsilon) && symbol == Token.Eof)
+			if (following.Contains(IToken.Epsilon) && symbol == IToken.Eof)
 			{
 				return true;
 			}
@@ -751,26 +752,26 @@ namespace Antlr4.Runtime
 			ATNState s = atn.states[GetState()];
 			IntervalSet following = atn.NextTokens(s);
 			//        System.out.println("following "+s+"="+following);
-			if (!following.Contains(Token.Epsilon))
+			if (!following.Contains(IToken.Epsilon))
 			{
 				return following;
 			}
 			IntervalSet expected = new IntervalSet();
 			expected.AddAll(following);
-			expected.Remove(Token.Epsilon);
-			while (ctx != null && ctx.invokingState >= 0 && following.Contains(Token.Epsilon)
-				)
+			expected.Remove(IToken.Epsilon);
+			while (ctx != null && ctx.invokingState >= 0 && following.Contains(IToken.Epsilon
+				))
 			{
 				ATNState invokingState = atn.states[ctx.invokingState];
 				RuleTransition rt = (RuleTransition)invokingState.Transition(0);
 				following = atn.NextTokens(rt.followState);
 				expected.AddAll(following);
-				expected.Remove(Token.Epsilon);
+				expected.Remove(IToken.Epsilon);
 				ctx = (ParserRuleContext)ctx.parent;
 			}
-			if (following.Contains(Token.Epsilon))
+			if (following.Contains(IToken.Epsilon))
 			{
-				expected.Add(Token.Eof);
+				expected.Add(IToken.Eof);
 			}
 			return expected;
 		}
@@ -815,7 +816,7 @@ namespace Antlr4.Runtime
 		public virtual IList<string> GetRuleInvocationStack(RuleContext p)
 		{
 			string[] ruleNames = GetRuleNames();
-			IList<string> stack = new AList<string>();
+			IList<string> stack = new List<string>();
 			while (p != null)
 			{
 				// compute what follows who invoked us
@@ -836,7 +837,7 @@ namespace Antlr4.Runtime
 		/// <summary>For debugging and other purposes</summary>
 		public virtual IList<string> GetDFAStrings()
 		{
-			IList<string> s = new AList<string>();
+			IList<string> s = new List<string>();
 			for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
 			{
 				DFA dfa = _interp.atn.decisionToDFA[d];
@@ -875,13 +876,13 @@ namespace Antlr4.Runtime
 		/// A convenience method for use most often with template rewrites.
 		/// Convert a List<Token> to List<String>
 		/// </remarks>
-		public virtual IList<string> ToStrings<_T0>(IList<_T0> tokens) where _T0:Token
+		public virtual IList<string> ToStrings<_T0>(IList<_T0> tokens) where _T0:IToken
 		{
 			if (tokens == null)
 			{
 				return null;
 			}
-			IList<string> strings = new AList<string>(tokens.Count);
+			IList<string> strings = new List<string>(tokens.Count);
 			for (int i = 0; i < tokens.Count; i++)
 			{
 				strings.AddItem(tokens[i].GetText());
diff --git a/Antlr4.Runtime/ParserRuleContext.cs b/Antlr4.Runtime/ParserRuleContext.cs
index 0ce8e34c3..8ef9212c3 100644
--- a/Antlr4.Runtime/ParserRuleContext.cs
+++ b/Antlr4.Runtime/ParserRuleContext.cs
@@ -96,7 +96,7 @@ namespace Antlr4.Runtime
 		/// if we are debugging/tracing.
 		/// This does not trace states visited during prediction.
 		/// </remarks>
-		public Token start;
+		public IToken start;
 
 		/// <summary>
 		/// For debugging/tracing purposes, we want to track all of the nodes in
@@ -118,7 +118,7 @@ namespace Antlr4.Runtime
 		/// if we are debugging/tracing.
 		/// This does not trace states visited during prediction.
 		/// </remarks>
-		public Token stop;
+		public IToken stop;
 
 		/// <summary>Set during parsing to identify which alt of rule parser is in.</summary>
 		/// <remarks>Set during parsing to identify which alt of rule parser is in.</remarks>
@@ -172,7 +172,7 @@ namespace Antlr4.Runtime
 		{
 			if (children == null)
 			{
-				children = new AList<IParseTree>();
+				children = new List<IParseTree>();
 			}
 			children.AddItem(t);
 		}
@@ -181,7 +181,7 @@ namespace Antlr4.Runtime
 		{
 			if (children == null)
 			{
-				children = new AList<IParseTree>();
+				children = new List<IParseTree>();
 			}
 			children.AddItem(ruleInvocation);
 		}
@@ -207,7 +207,7 @@ namespace Antlr4.Runtime
 		//		if ( states==null ) states = new ArrayList<Integer>();
 		//		states.add(s);
 		//	}
-		public virtual ITerminalNode AddChild(Token matchedToken)
+		public virtual ITerminalNode AddChild(IToken matchedToken)
 		{
 			TerminalNodeImpl t = new TerminalNodeImpl(matchedToken);
 			AddChild(t);
@@ -215,7 +215,7 @@ namespace Antlr4.Runtime
 			return t;
 		}
 
-		public virtual IErrorNode AddErrorNode(Token badToken)
+		public virtual IErrorNode AddErrorNode(IToken badToken)
 		{
 			ErrorNodeImpl t = new ErrorNodeImpl(badToken);
 			AddChild(t);
@@ -269,7 +269,7 @@ namespace Antlr4.Runtime
 				if (o is ITerminalNode)
 				{
 					ITerminalNode tnode = (ITerminalNode)o;
-					Token symbol = tnode.GetSymbol();
+					IToken symbol = tnode.GetSymbol();
 					if (symbol.GetType() == ttype)
 					{
 						j++;
@@ -295,12 +295,12 @@ namespace Antlr4.Runtime
 				if (o is ITerminalNode)
 				{
 					ITerminalNode tnode = (ITerminalNode)o;
-					Token symbol = tnode.GetSymbol();
+					IToken symbol = tnode.GetSymbol();
 					if (symbol.GetType() == ttype)
 					{
 						if (tokens == null)
 						{
-							tokens = new AList<ITerminalNode>();
+							tokens = new List<ITerminalNode>();
 						}
 						tokens.AddItem(tnode);
 					}
@@ -333,7 +333,7 @@ namespace Antlr4.Runtime
 				{
 					if (contexts == null)
 					{
-						contexts = new AList<T>();
+						contexts = new List<T>();
 					}
 					contexts.AddItem(ctxType.Cast(o));
 				}
@@ -359,12 +359,12 @@ namespace Antlr4.Runtime
 			return Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex());
 		}
 
-		public virtual Token GetStart()
+		public virtual IToken GetStart()
 		{
 			return start;
 		}
 
-		public virtual Token GetStop()
+		public virtual IToken GetStop()
 		{
 			return stop;
 		}
diff --git a/Antlr4.Runtime/ProxyErrorListener.cs b/Antlr4.Runtime/ProxyErrorListener`1.cs
similarity index 100%
rename from Antlr4.Runtime/ProxyErrorListener.cs
rename to Antlr4.Runtime/ProxyErrorListener`1.cs
diff --git a/Antlr4.Runtime/ProxyParserErrorListener.cs b/Antlr4.Runtime/ProxyParserErrorListener.cs
index 9168835f4..59232baa6 100644
--- a/Antlr4.Runtime/ProxyParserErrorListener.cs
+++ b/Antlr4.Runtime/ProxyParserErrorListener.cs
@@ -36,9 +36,9 @@ using Sharpen;
 namespace Antlr4.Runtime
 {
 	/// <author>Sam Harwell</author>
-	public class ProxyParserErrorListener : ProxyErrorListener<Token>, IParserErrorListener
+	public class ProxyParserErrorListener : ProxyErrorListener<IToken>, IParserErrorListener
 	{
-		public ProxyParserErrorListener(ICollection<IAntlrErrorListener<Token>> delegates
+		public ProxyParserErrorListener(ICollection<IAntlrErrorListener<IToken>> delegates
 			) : base(delegates)
 		{
 		}
@@ -46,7 +46,7 @@ namespace Antlr4.Runtime
 		public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
 			 stopIndex, BitSet ambigAlts, ATNConfigSet configs)
 		{
-			foreach (IAntlrErrorListener<Token> listener in GetDelegates())
+			foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
 			{
 				if (!(listener is IParserErrorListener))
 				{
@@ -61,7 +61,7 @@ namespace Antlr4.Runtime
 		public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
 			, int stopIndex, SimulatorState initialState)
 		{
-			foreach (IAntlrErrorListener<Token> listener in GetDelegates())
+			foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
 			{
 				if (!(listener is IParserErrorListener))
 				{
@@ -76,7 +76,7 @@ namespace Antlr4.Runtime
 		public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
 			, int stopIndex, SimulatorState acceptState)
 		{
-			foreach (IAntlrErrorListener<Token> listener in GetDelegates())
+			foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
 			{
 				if (!(listener is IParserErrorListener))
 				{
diff --git a/Antlr4.Runtime/RecognitionException.cs b/Antlr4.Runtime/RecognitionException.cs
index 586dd1c5b..88fe4ffcc 100644
--- a/Antlr4.Runtime/RecognitionException.cs
+++ b/Antlr4.Runtime/RecognitionException.cs
@@ -51,7 +51,7 @@ namespace Antlr4.Runtime
 
 		private RuleContext ctx;
 
-		private IntStream input;
+		private IIntStream input;
 
 		/// <summary>The current Token when an error occurred.</summary>
 		/// <remarks>
@@ -59,11 +59,11 @@ namespace Antlr4.Runtime
 		/// can retrieve the ith Token, we have to track the Token object.
 		/// For parsers.  Even when it's a tree parser, token might be set.
 		/// </remarks>
-		private Token offendingToken;
+		private IToken offendingToken;
 
 		private int offendingState;
 
-		public RecognitionException(Lexer lexer, CharStream input)
+		public RecognitionException(Lexer lexer, ICharStream input)
 		{
 			// TODO: make a dummy recognizer for the interpreter to use?
 			// Next two (ctx,input) should be what is in recognizer, but
@@ -72,7 +72,7 @@ namespace Antlr4.Runtime
 			this.input = input;
 		}
 
-		public RecognitionException(Recognizer<Token, object> recognizer, IntStream input
+		public RecognitionException(Recognizer<IToken, object> recognizer, IIntStream input
 			, ParserRuleContext ctx)
 		{
 			this.recognizer = recognizer;
@@ -84,8 +84,8 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		public RecognitionException(string message, Recognizer<Token, object> recognizer, 
-			IntStream input, ParserRuleContext ctx) : base(message)
+		public RecognitionException(string message, Recognizer<IToken, object> recognizer
+			, IIntStream input, ParserRuleContext ctx) : base(message)
 		{
 			this.recognizer = recognizer;
 			this.input = input;
@@ -132,17 +132,17 @@ namespace Antlr4.Runtime
 			return ctx;
 		}
 
-		public virtual IntStream GetInputStream()
+		public virtual IIntStream GetInputStream()
 		{
 			return input;
 		}
 
-		public virtual Token GetOffendingToken()
+		public virtual IToken GetOffendingToken()
 		{
 			return offendingToken;
 		}
 
-		protected internal void SetOffendingToken(Token offendingToken)
+		protected internal void SetOffendingToken(IToken offendingToken)
 		{
 			this.offendingToken = offendingToken;
 		}
diff --git a/Antlr4.Runtime/Recognizer.cs b/Antlr4.Runtime/Recognizer`2.cs
similarity index 97%
rename from Antlr4.Runtime/Recognizer.cs
rename to Antlr4.Runtime/Recognizer`2.cs
index 258ce4b27..0dc8d6fdd 100644
--- a/Antlr4.Runtime/Recognizer.cs
+++ b/Antlr4.Runtime/Recognizer`2.cs
@@ -115,7 +115,7 @@ namespace Antlr4.Runtime
 		/// your token objects because you don't have to go modify your lexer
 		/// so that it creates a new Java type.
 		/// </remarks>
-		public virtual string GetTokenErrorDisplay(Token t)
+		public virtual string GetTokenErrorDisplay(IToken t)
 		{
 			if (t == null)
 			{
@@ -124,7 +124,7 @@ namespace Antlr4.Runtime
 			string s = t.GetText();
 			if (s == null)
 			{
-				if (t.GetType() == Token.Eof)
+				if (t.GetType() == IToken.Eof)
 				{
 					s = "<EOF>";
 				}
@@ -165,7 +165,7 @@ namespace Antlr4.Runtime
 		[NotNull]
 		public virtual IList<IAntlrErrorListener<Symbol>> GetErrorListeners()
 		{
-			return new AList<IAntlrErrorListener<Symbol>>(_listeners);
+			return new List<IAntlrErrorListener<Symbol>>(_listeners);
 		}
 
 		public virtual IAntlrErrorListener<Symbol> GetErrorListenerDispatch()
@@ -214,6 +214,6 @@ namespace Antlr4.Runtime
 		}
 
 		//		if ( traceATNStates ) _ctx.trace(atnState);
-		public abstract IntStream GetInputStream();
+		public abstract IIntStream GetInputStream();
 	}
 }
diff --git a/Antlr4.Runtime/RuleContext.cs b/Antlr4.Runtime/RuleContext.cs
index 666c26033..e104b68e2 100644
--- a/Antlr4.Runtime/RuleContext.cs
+++ b/Antlr4.Runtime/RuleContext.cs
@@ -182,14 +182,14 @@ namespace Antlr4.Runtime
 
 		/// <summary>Call this method to view a parse tree in a dialog box visually.</summary>
 		/// <remarks>Call this method to view a parse tree in a dialog box visually.</remarks>
-		public virtual Future<JDialog> Inspect(Parser parser)
+		public virtual IFuture<JDialog> Inspect(Parser parser)
 		{
 			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
 				null;
 			return Inspect(ruleNames);
 		}
 
-		public virtual Future<JDialog> Inspect(IList<string> ruleNames)
+		public virtual IFuture<JDialog> Inspect(IList<string> ruleNames)
 		{
 			TreeViewer viewer = new TreeViewer(ruleNames, this);
 			return viewer.Open();
diff --git a/Antlr4.Runtime/TokenStreamRewriter.cs b/Antlr4.Runtime/TokenStreamRewriter.cs
index 602da1199..95cb4c017 100644
--- a/Antlr4.Runtime/TokenStreamRewriter.cs
+++ b/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -156,7 +156,7 @@ namespace Antlr4.Runtime
 			public override int Execute(StringBuilder buf)
 			{
 				buf.Append(text);
-				if (tokens.Get(index).GetType() != Token.Eof)
+				if (tokens.Get(index).GetType() != IToken.Eof)
 				{
 					buf.Append(tokens.Get(index).GetText());
 				}
@@ -221,8 +221,8 @@ namespace Antlr4.Runtime
 		{
 			this.tokens = tokens;
 			programs = new Dictionary<string, IList<TokenStreamRewriter.RewriteOperation>>();
-			programs.Put(DefaultProgramName, new AList<TokenStreamRewriter.RewriteOperation>(
-				ProgramInitSize));
+			programs.Put(DefaultProgramName, new List<TokenStreamRewriter.RewriteOperation>(ProgramInitSize
+				));
 			lastRewriteTokenIndexes = new Dictionary<string, int>();
 		}
 
@@ -266,7 +266,7 @@ namespace Antlr4.Runtime
 			Rollback(programName, MinTokenIndex);
 		}
 
-		public virtual void InsertAfter(Token t, object text)
+		public virtual void InsertAfter(IToken t, object text)
 		{
 			InsertAfter(DefaultProgramName, t, text);
 		}
@@ -276,7 +276,7 @@ namespace Antlr4.Runtime
 			InsertAfter(DefaultProgramName, index, text);
 		}
 
-		public virtual void InsertAfter(string programName, Token t, object text)
+		public virtual void InsertAfter(string programName, IToken t, object text)
 		{
 			InsertAfter(programName, t.GetTokenIndex(), text);
 		}
@@ -287,7 +287,7 @@ namespace Antlr4.Runtime
 			InsertBefore(programName, index + 1, text);
 		}
 
-		public virtual void InsertBefore(Token t, object text)
+		public virtual void InsertBefore(IToken t, object text)
 		{
 			InsertBefore(DefaultProgramName, t, text);
 		}
@@ -297,7 +297,7 @@ namespace Antlr4.Runtime
 			InsertBefore(DefaultProgramName, index, text);
 		}
 
-		public virtual void InsertBefore(string programName, Token t, object text)
+		public virtual void InsertBefore(string programName, IToken t, object text)
 		{
 			InsertBefore(programName, t.GetTokenIndex(), text);
 		}
@@ -321,12 +321,12 @@ namespace Antlr4.Runtime
 			Replace(DefaultProgramName, from, to, text);
 		}
 
-		public virtual void Replace(Token indexT, object text)
+		public virtual void Replace(IToken indexT, object text)
 		{
 			Replace(DefaultProgramName, indexT, indexT, text);
 		}
 
-		public virtual void Replace(Token from, Token to, object text)
+		public virtual void Replace(IToken from, IToken to, object text)
 		{
 			Replace(DefaultProgramName, from, to, text);
 		}
@@ -345,7 +345,7 @@ namespace Antlr4.Runtime
 			rewrites.AddItem(op);
 		}
 
-		public virtual void Replace(string programName, Token from, Token to, object text
+		public virtual void Replace(string programName, IToken from, IToken to, object text
 			)
 		{
 			Replace(programName, from.GetTokenIndex(), to.GetTokenIndex(), text);
@@ -361,12 +361,12 @@ namespace Antlr4.Runtime
 			Delete(DefaultProgramName, from, to);
 		}
 
-		public virtual void Delete(Token indexT)
+		public virtual void Delete(IToken indexT)
 		{
 			Delete(DefaultProgramName, indexT, indexT);
 		}
 
-		public virtual void Delete(Token from, Token to)
+		public virtual void Delete(IToken from, IToken to)
 		{
 			Delete(DefaultProgramName, from, to);
 		}
@@ -376,7 +376,7 @@ namespace Antlr4.Runtime
 			Replace(programName, from, to, null);
 		}
 
-		public virtual void Delete(string programName, Token from, Token to)
+		public virtual void Delete(string programName, IToken from, IToken to)
 		{
 			Replace(programName, from, to, null);
 		}
@@ -416,7 +416,7 @@ namespace Antlr4.Runtime
 		private IList<TokenStreamRewriter.RewriteOperation> InitializeProgram(string name
 			)
 		{
-			IList<TokenStreamRewriter.RewriteOperation> @is = new AList<TokenStreamRewriter.RewriteOperation
+			IList<TokenStreamRewriter.RewriteOperation> @is = new List<TokenStreamRewriter.RewriteOperation
 				>(ProgramInitSize);
 			programs.Put(name, @is);
 			return @is;
@@ -484,11 +484,11 @@ namespace Antlr4.Runtime
 				TokenStreamRewriter.RewriteOperation op = indexToOp.Get(i);
 				Sharpen.Collections.Remove(indexToOp, i);
 				// remove so any left have index size-1
-				Token t = tokens.Get(i);
+				IToken t = tokens.Get(i);
 				if (op == null)
 				{
 					// no operation at that index, just dump token
-					if (t.GetType() != Token.Eof)
+					if (t.GetType() != IToken.Eof)
 					{
 						buf.Append(t.GetText());
 					}
@@ -725,7 +725,7 @@ namespace Antlr4.Runtime
 			 before) where T:TokenStreamRewriter.RewriteOperation where _T1:TokenStreamRewriter.RewriteOperation
 		{
 			System.Type kind = typeof(T);
-			IList<T> ops = new AList<T>();
+			IList<T> ops = new List<T>();
 			for (int i = 0; i < before && i < rewrites.Count; i++)
 			{
 				TokenStreamRewriter.RewriteOperation op = rewrites[i];
diff --git a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
similarity index 100%
rename from Antlr4.Runtime/Tree/AbstractParseTreeVisitor.cs
rename to Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
diff --git a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
index 311c36af7..f7b545b9d 100644
--- a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
@@ -46,7 +46,7 @@ namespace Antlr4.Runtime.Tree
 	/// </remarks>
 	public class ErrorNodeImpl : TerminalNodeImpl, IErrorNode
 	{
-		public ErrorNodeImpl(Token token) : base(token)
+		public ErrorNodeImpl(IToken token) : base(token)
 		{
 		}
 
diff --git a/Antlr4.Runtime/Tree/ErrorNode.cs b/Antlr4.Runtime/Tree/IErrorNode.cs
similarity index 95%
rename from Antlr4.Runtime/Tree/ErrorNode.cs
rename to Antlr4.Runtime/Tree/IErrorNode.cs
index fc23ca59e..1e6caed4a 100644
--- a/Antlr4.Runtime/Tree/ErrorNode.cs
+++ b/Antlr4.Runtime/Tree/IErrorNode.cs
@@ -27,11 +27,12 @@
  *  (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.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface ErrorNode : ITerminalNode
+	public interface IErrorNode : ITerminalNode
 	{
 	}
 }
diff --git a/Antlr4.Runtime/Tree/ParseTree.cs b/Antlr4.Runtime/Tree/IParseTree.cs
similarity index 93%
rename from Antlr4.Runtime/Tree/ParseTree.cs
rename to Antlr4.Runtime/Tree/IParseTree.cs
index 1123ebaf8..2f02430b2 100644
--- a/Antlr4.Runtime/Tree/ParseTree.cs
+++ b/Antlr4.Runtime/Tree/IParseTree.cs
@@ -28,6 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -41,12 +42,12 @@ namespace Antlr4.Runtime.Tree
 	/// and leaf nodes, token matches.
 	/// <p/>
 	/// The payload is either a
-	/// <see cref="Antlr4.Runtime.Token">Antlr4.Runtime.Token</see>
+	/// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
 	/// or a
 	/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
 	/// object.
 	/// </summary>
-	public interface ParseTree : ISyntaxTree
+	public interface IParseTree : ISyntaxTree
 	{
 		// the following methods narrow the return type; they are not additional methods
 		IParseTree GetParent();
@@ -55,7 +56,7 @@ namespace Antlr4.Runtime.Tree
 
 		/// <summary>
 		/// The
-		/// <see cref="ParseTreeVisitor{Result}">ParseTreeVisitor&lt;Result&gt;</see>
+		/// <see cref="IParseTreeVisitor{Result}">IParseTreeVisitor&lt;Result&gt;</see>
 		/// needs a double dispatch method.
 		/// </summary>
 		T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T;
diff --git a/Antlr4.Runtime/Tree/ParseTreeListener.cs b/Antlr4.Runtime/Tree/IParseTreeListener.cs
similarity index 96%
rename from Antlr4.Runtime/Tree/ParseTreeListener.cs
rename to Antlr4.Runtime/Tree/IParseTreeListener.cs
index 91d574914..1865dee64 100644
--- a/Antlr4.Runtime/Tree/ParseTreeListener.cs
+++ b/Antlr4.Runtime/Tree/IParseTreeListener.cs
@@ -28,11 +28,12 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface ParseTreeListener
+	public interface IParseTreeListener
 	{
 		void VisitTerminal(ITerminalNode node);
 
diff --git a/Antlr4.Runtime/Tree/ParseTreeVisitor.cs b/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
similarity index 98%
rename from Antlr4.Runtime/Tree/ParseTreeVisitor.cs
rename to Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
index 42410bc9e..9104a5325 100644
--- a/Antlr4.Runtime/Tree/ParseTreeVisitor.cs
+++ b/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
@@ -27,6 +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.
  */
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -43,7 +44,7 @@ namespace Antlr4.Runtime.Tree
 	/// </remarks>
 	/// <author>Sam Harwell</author>
 	/// <?></?>
-	public interface ParseTreeVisitor<Result>
+	public interface IParseTreeVisitor<Result>
 	{
 		/// <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>
diff --git a/Antlr4.Runtime/Tree/RuleNode.cs b/Antlr4.Runtime/Tree/IRuleNode.cs
similarity index 96%
rename from Antlr4.Runtime/Tree/RuleNode.cs
rename to Antlr4.Runtime/Tree/IRuleNode.cs
index 6c4dfafd7..33cbdc9ae 100644
--- a/Antlr4.Runtime/Tree/RuleNode.cs
+++ b/Antlr4.Runtime/Tree/IRuleNode.cs
@@ -28,11 +28,12 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface RuleNode : IParseTree
+	public interface IRuleNode : IParseTree
 	{
 		RuleContext GetRuleContext();
 
diff --git a/Antlr4.Runtime/Tree/SyntaxTree.cs b/Antlr4.Runtime/Tree/ISyntaxTree.cs
similarity index 94%
rename from Antlr4.Runtime/Tree/SyntaxTree.cs
rename to Antlr4.Runtime/Tree/ISyntaxTree.cs
index c815b6e4c..2ad7e3a5f 100644
--- a/Antlr4.Runtime/Tree/SyntaxTree.cs
+++ b/Antlr4.Runtime/Tree/ISyntaxTree.cs
@@ -28,6 +28,7 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -41,13 +42,13 @@ namespace Antlr4.Runtime.Tree
 	/// 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 SyntaxTree : ITree
+	public interface ISyntaxTree : ITree
 	{
 		/// <summary>
 		/// Return an
 		/// <see cref="Antlr4.Runtime.Misc.Interval">Antlr4.Runtime.Misc.Interval</see>
 		/// indicating the index in the
-		/// <see cref="ITokenStream">ITokenStream</see>
+		/// <see cref="Antlr4.Runtime.ITokenStream">Antlr4.Runtime.ITokenStream</see>
 		/// of the first and last token associated with this
 		/// subtree. If this node is a leaf, then the interval represents a single
 		/// token.
diff --git a/Antlr4.Runtime/Tree/TerminalNode.cs b/Antlr4.Runtime/Tree/ITerminalNode.cs
similarity index 94%
rename from Antlr4.Runtime/Tree/TerminalNode.cs
rename to Antlr4.Runtime/Tree/ITerminalNode.cs
index ff0103340..7103956ae 100644
--- a/Antlr4.Runtime/Tree/TerminalNode.cs
+++ b/Antlr4.Runtime/Tree/ITerminalNode.cs
@@ -28,13 +28,14 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface TerminalNode : IParseTree
+	public interface ITerminalNode : IParseTree
 	{
-		Token GetSymbol();
+		IToken GetSymbol();
 
 		IRuleNode GetParent();
 	}
diff --git a/Antlr4.Runtime/Tree/Tree.cs b/Antlr4.Runtime/Tree/ITree.cs
similarity index 94%
rename from Antlr4.Runtime/Tree/Tree.cs
rename to Antlr4.Runtime/Tree/ITree.cs
index 3e6ce5a40..66d065007 100644
--- a/Antlr4.Runtime/Tree/Tree.cs
+++ b/Antlr4.Runtime/Tree/ITree.cs
@@ -27,6 +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.
  */
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
@@ -37,7 +38,7 @@ namespace Antlr4.Runtime.Tree
 	/// 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 Tree
+	public interface ITree
 	{
 		/// <summary>The parent of this node.</summary>
 		/// <remarks>
@@ -50,13 +51,13 @@ namespace Antlr4.Runtime.Tree
 		/// <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.Token">Antlr4.Runtime.Token</see>
+		/// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
 		/// representing
 		/// a leaf node or a
 		/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
 		/// object representing a rule
 		/// invocation. For abstract syntax trees (ASTs), this is a
-		/// <see cref="Antlr4.Runtime.Token">Antlr4.Runtime.Token</see>
+		/// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
 		/// object.
 		/// </remarks>
 		object GetPayload();
diff --git a/Antlr4.Runtime/Tree/ParseTreeProperty.cs b/Antlr4.Runtime/Tree/ParseTreeProperty`1.cs
similarity index 100%
rename from Antlr4.Runtime/Tree/ParseTreeProperty.cs
rename to Antlr4.Runtime/Tree/ParseTreeProperty`1.cs
diff --git a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
index 7fcfb1f07..c5dc2d319 100644
--- a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
@@ -29,17 +29,18 @@
  */
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
 using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
 	public class TerminalNodeImpl : ITerminalNode
 	{
-		public Token symbol;
+		public IToken symbol;
 
 		public IRuleNode parent;
 
-		public TerminalNodeImpl(Token symbol)
+		public TerminalNodeImpl(IToken symbol)
 		{
 			this.symbol = symbol;
 		}
@@ -49,7 +50,7 @@ namespace Antlr4.Runtime.Tree
 			return null;
 		}
 
-		public virtual Token GetSymbol()
+		public virtual IToken GetSymbol()
 		{
 			return symbol;
 		}
@@ -59,7 +60,7 @@ namespace Antlr4.Runtime.Tree
 			return parent;
 		}
 
-		public virtual Token GetPayload()
+		public virtual IToken GetPayload()
 		{
 			return symbol;
 		}
@@ -102,7 +103,7 @@ namespace Antlr4.Runtime.Tree
 		{
 			if (symbol != null)
 			{
-				if (symbol.GetType() == Token.Eof)
+				if (symbol.GetType() == IToken.Eof)
 				{
 					return "<EOF>";
 				}
diff --git a/Antlr4.Runtime/Tree/Trees.cs b/Antlr4.Runtime/Tree/Trees.cs
index 0002b6e24..2cf658eb4 100644
--- a/Antlr4.Runtime/Tree/Trees.cs
+++ b/Antlr4.Runtime/Tree/Trees.cs
@@ -32,6 +32,7 @@ using System.IO;
 using System.Text;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Misc;
+using Antlr4.Runtime.Tree;
 using Antlr4.Runtime.Tree.Gui;
 using Sharpen;
 
@@ -162,9 +163,9 @@ namespace Antlr4.Runtime.Tree
 						if (t is ITerminalNode)
 						{
 							object symbol = ((ITerminalNode)t).GetSymbol();
-							if (symbol is Token)
+							if (symbol is IToken)
 							{
-								string s = ((Token)symbol).GetText();
+								string s = ((IToken)symbol).GetText();
 								return s;
 							}
 						}
@@ -173,9 +174,9 @@ namespace Antlr4.Runtime.Tree
 			}
 			// no recog for rule names
 			object payload = t.GetPayload();
-			if (payload is Token)
+			if (payload is IToken)
 			{
-				return ((Token)payload).GetText();
+				return ((IToken)payload).GetText();
 			}
 			return t.GetPayload().ToString();
 		}
@@ -192,7 +193,7 @@ namespace Antlr4.Runtime.Tree
 			{
 				return Sharpen.Collections.EmptyList();
 			}
-			IList<ITree> ancestors = new AList<ITree>();
+			IList<ITree> ancestors = new List<ITree>();
 			t = t.GetParent();
 			while (t != null)
 			{
diff --git a/Antlr4.Runtime/UnbufferedCharStream.cs b/Antlr4.Runtime/UnbufferedCharStream.cs
index b390d0965..cbcd8fe1e 100644
--- a/Antlr4.Runtime/UnbufferedCharStream.cs
+++ b/Antlr4.Runtime/UnbufferedCharStream.cs
@@ -42,7 +42,7 @@ namespace Antlr4.Runtime
 	/// 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 : CharStream
+	public class UnbufferedCharStream : ICharStream
 	{
 		/// <summary>A moving window buffer of the data being scanned.</summary>
 		/// <remarks>
@@ -173,7 +173,7 @@ namespace Antlr4.Runtime
 		// prime
 		public virtual void Consume()
 		{
-			if (La(1) == IntStream.Eof)
+			if (La(1) == IIntStream.Eof)
 			{
 				throw new InvalidOperationException("cannot consume EOF");
 			}
@@ -234,7 +234,7 @@ namespace Antlr4.Runtime
 		{
 			for (int i = 0; i < n; i++)
 			{
-				if (this.n > 0 && data[this.n - 1] == IntStream.Eof)
+				if (this.n > 0 && data[this.n - 1] == IIntStream.Eof)
 				{
 					return i;
 				}
@@ -286,12 +286,12 @@ namespace Antlr4.Runtime
 			}
 			if (index > n)
 			{
-				return IntStream.Eof;
+				return IIntStream.Eof;
 			}
 			int c = data[index];
-			if (c == (char)IntStream.Eof)
+			if (c == (char)IIntStream.Eof)
 			{
-				return IntStream.Eof;
+				return IIntStream.Eof;
 			}
 			return c;
 		}
diff --git a/Antlr4.Runtime/UnbufferedTokenStream.cs b/Antlr4.Runtime/UnbufferedTokenStream.cs
index 3892fa3e5..1c4942ecb 100644
--- a/Antlr4.Runtime/UnbufferedTokenStream.cs
+++ b/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -47,7 +47,7 @@ namespace Antlr4.Runtime
 		/// resets so
 		/// we start filling at index 0 again.
 		/// </remarks>
-		protected internal Token[] tokens;
+		protected internal IToken[] tokens;
 
 		/// <summary>
 		/// The number of tokens currently in
@@ -98,7 +98,7 @@ namespace Antlr4.Runtime
 		/// <code>LT(-1)</code>
 		/// token for the current position.
 		/// </summary>
-		protected internal Token lastToken;
+		protected internal IToken lastToken;
 
 		/// <summary>
 		/// When
@@ -112,7 +112,7 @@ namespace Antlr4.Runtime
 		/// <code>null</code>
 		/// .
 		/// </summary>
-		protected internal Token lastTokenBufferStart;
+		protected internal IToken lastTokenBufferStart;
 
 		/// <summary>Absolute token index.</summary>
 		/// <remarks>
@@ -135,14 +135,14 @@ namespace Antlr4.Runtime
 		public UnbufferedTokenStream(ITokenSource tokenSource, int bufferSize)
 		{
 			this.tokenSource = tokenSource;
-			Token[] tokens = new Token[bufferSize];
+			IToken[] tokens = new IToken[bufferSize];
 			this.tokens = tokens;
 			n = 0;
 			Fill(1);
 		}
 
 		// prime the pump
-		public virtual Token Get(int i)
+		public virtual IToken Get(int i)
 		{
 			int bufferStartIndex = GetBufferStartIndex();
 			if (i < bufferStartIndex || i >= bufferStartIndex + n)
@@ -153,7 +153,7 @@ namespace Antlr4.Runtime
 			return tokens[i - bufferStartIndex];
 		}
 
-		public virtual Token Lt(int i)
+		public virtual IToken Lt(int i)
 		{
 			if (i == -1)
 			{
@@ -167,7 +167,7 @@ namespace Antlr4.Runtime
 			}
 			if (index >= n)
 			{
-				System.Diagnostics.Debug.Assert(n > 0 && tokens[n - 1].GetType() == Token.Eof);
+				System.Diagnostics.Debug.Assert(n > 0 && tokens[n - 1].GetType() == IToken.Eof);
 				return tokens[n - 1];
 			}
 			return tokens[index];
@@ -196,7 +196,7 @@ namespace Antlr4.Runtime
 		}
 
 		[NotNull]
-		public virtual string GetText(Token start, Token stop)
+		public virtual string GetText(IToken start, IToken stop)
 		{
 			if (start != null && stop != null)
 			{
@@ -208,7 +208,7 @@ namespace Antlr4.Runtime
 
 		public virtual void Consume()
 		{
-			if (La(1) == Token.Eof)
+			if (La(1) == IToken.Eof)
 			{
 				throw new InvalidOperationException("cannot consume EOF");
 			}
@@ -269,17 +269,17 @@ namespace Antlr4.Runtime
 		{
 			for (int i = 0; i < n; i++)
 			{
-				if (this.n > 0 && tokens[this.n - 1].GetType() == Token.Eof)
+				if (this.n > 0 && tokens[this.n - 1].GetType() == IToken.Eof)
 				{
 					return i;
 				}
-				Token t = tokenSource.NextToken();
+				IToken t = tokenSource.NextToken();
 				Add(t);
 			}
 			return n;
 		}
 
-		protected internal virtual void Add(Token t)
+		protected internal virtual void Add(IToken t)
 		{
 			if (n >= tokens.Length)
 			{
@@ -408,7 +408,7 @@ namespace Antlr4.Runtime
 			StringBuilder buf = new StringBuilder();
 			for (int i = a; i <= b; i++)
 			{
-				Token t = tokens[i];
+				IToken t = tokens[i];
 				buf.Append(t.GetText());
 			}
 			return buf.ToString();
diff --git a/reference/sharpen b/reference/sharpen
index 1f2dadc3b..8aa52c8df 160000
--- a/reference/sharpen
+++ b/reference/sharpen
@@ -1 +1 @@
-Subproject commit 1f2dadc3bf48f43fdec8e6937b36862f124b1c38
+Subproject commit 8aa52c8df7ecc4daf6331ae4ef75320bff24ceeb
diff --git a/reference/sharpen-all-options.txt b/reference/sharpen-all-options.txt
index e87226813..b7cb7a646 100644
--- a/reference/sharpen-all-options.txt
+++ b/reference/sharpen-all-options.txt
@@ -1,6 +1,7 @@
 -pascalCase+ 
 -nativeTypeSystem 
 -organizeUsings
+-nativeInterfaces
 
 -methodMapping System.out.println System.Console.WriteLine
 
@@ -112,7 +113,7 @@
 -typeMapping java.lang.Process Sharpen.SystemProcess
 -typeMapping java.net.InetAddress System.Net.IPAddress
 -typeMapping java.util.TimeZone System.TimeZoneInfo
--typeMapping java.util.ArrayList<> Sharpen.AList
+-typeMapping java.util.ArrayList<> System.Collections.Generic.List
 -typeMapping java.util.zip.Inflater ICSharpCode.SharpZipLib.Zip.Compression.Inflater
 -typeMapping java.util.zip.Deflater ICSharpCode.SharpZipLib.Zip.Compression.Deflater
 -typeMapping java.util.zip.ZipException ICSharpCode.SharpZipLib.SharpZipBaseException
@@ -185,21 +186,5 @@
 
 -typeMapping org.antlr.v4.runtime.ANTLRErrorListener<> IAntlrErrorListener
 -typeMapping org.antlr.v4.runtime.ANTLRErrorStrategy IAntlrErrorStrategy
--typeMapping org.antlr.v4.runtime.ParserErrorListener IParserErrorListener
--typeMapping org.antlr.v4.runtime.TokenFactory ITokenFactory
--typeMapping org.antlr.v4.runtime.TokenSource ITokenSource
--typeMapping org.antlr.v4.runtime.TokenStream ITokenStream
--typeMapping org.antlr.v4.runtime.WritableToken IWritableToken
-
--typeMapping org.antlr.v4.runtime.dfa.EdgeMap<> IEdgeMap
-
--typeMapping org.antlr.v4.runtime.misc.IntSet IIntSet
-
--typeMapping org.antlr.v4.runtime.tree.ErrorNode IErrorNode
--typeMapping org.antlr.v4.runtime.tree.ParseTree IParseTree
--typeMapping org.antlr.v4.runtime.tree.ParseTreeListener IParseTreeListener
--typeMapping org.antlr.v4.runtime.tree.ParseTreeVisitor<> IParseTreeVisitor
--typeMapping org.antlr.v4.runtime.tree.RuleNode IRuleNode
--typeMapping org.antlr.v4.runtime.tree.SyntaxTree ISyntaxTree
--typeMapping org.antlr.v4.runtime.tree.TerminalNode ITerminalNode
--typeMapping org.antlr.v4.runtime.tree.Tree ITree
+-typeMapping org.antlr.v4.runtime.ANTLRFileStream AntlrFileStream
+-typeMapping org.antlr.v4.runtime.ANTLRInputStream AntlrInputStream

From d21e39305996a02ef7aa5d1cb5efe983df89fd4c Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Fri, 15 Feb 2013 16:40:34 -0600
Subject: [PATCH 05/10] Regenerate code after ignoring several more types and
 methods

---
 Antlr4.Runtime/Antlr4.Runtime.csproj          |   8 -
 .../Misc/AbstractEqualityComparator`1.cs      |  50 ---
 Antlr4.Runtime/Misc/IEqualityComparator`1.cs  |  74 ----
 Antlr4.Runtime/Misc/IntegerList.cs            | 346 ------------------
 Antlr4.Runtime/Misc/IntegerStack.cs           |  65 ----
 .../Misc/ObjectEqualityComparator.cs          |  97 -----
 Antlr4.Runtime/Misc/Tuple.cs                  |  58 ---
 Antlr4.Runtime/Misc/Tuple`2.cs                |  84 -----
 Antlr4.Runtime/Misc/Tuple`3.cs                |  93 -----
 Antlr4.Runtime/Misc/Utils.cs                  | 113 ------
 reference/antlr4                              |   2 +-
 11 files changed, 1 insertion(+), 989 deletions(-)
 delete mode 100644 Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs
 delete mode 100644 Antlr4.Runtime/Misc/IEqualityComparator`1.cs
 delete mode 100644 Antlr4.Runtime/Misc/IntegerList.cs
 delete mode 100644 Antlr4.Runtime/Misc/IntegerStack.cs
 delete mode 100644 Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
 delete mode 100644 Antlr4.Runtime/Misc/Tuple.cs
 delete mode 100644 Antlr4.Runtime/Misc/Tuple`2.cs
 delete mode 100644 Antlr4.Runtime/Misc/Tuple`3.cs

diff --git a/Antlr4.Runtime/Antlr4.Runtime.csproj b/Antlr4.Runtime/Antlr4.Runtime.csproj
index 861c74ab2..ffa35b47e 100644
--- a/Antlr4.Runtime/Antlr4.Runtime.csproj
+++ b/Antlr4.Runtime/Antlr4.Runtime.csproj
@@ -117,30 +117,22 @@
     <Compile Include="IWritableToken.cs" />
     <Compile Include="Lexer.cs" />
     <Compile Include="LexerNoViableAltException.cs" />
-    <Compile Include="Misc\AbstractEqualityComparator`1.cs" />
     <Compile Include="Misc\Args.cs" />
     <Compile Include="Misc\Array2DHashSet`1.cs" />
     <Compile Include="Misc\DoubleKeyMap`3.cs" />
     <Compile Include="Misc\FlexibleHashMap`2.cs" />
-    <Compile Include="Misc\IEqualityComparator`1.cs" />
     <Compile Include="Misc\IFunc0`1.cs" />
     <Compile Include="Misc\IFunc1`2.cs" />
     <Compile Include="Misc\IIntSet.cs" />
-    <Compile Include="Misc\IntegerList.cs" />
-    <Compile Include="Misc\IntegerStack.cs" />
     <Compile Include="Misc\Interval.cs" />
     <Compile Include="Misc\IntervalSet.cs" />
     <Compile Include="Misc\IPredicate`1.cs" />
     <Compile Include="Misc\MultiMap`2.cs" />
-    <Compile Include="Misc\ObjectEqualityComparator.cs" />
     <Compile Include="Misc\OrderedHashSet`1.cs" />
     <Compile Include="Misc\ParseCanceledException.cs" />
     <Compile Include="Misc\RuleDependencyChecker.cs" />
     <Compile Include="Misc\RuleDependencyProcessor.cs" />
     <Compile Include="Misc\TestRig.cs" />
-    <Compile Include="Misc\Tuple.cs" />
-    <Compile Include="Misc\Tuple`2.cs" />
-    <Compile Include="Misc\Tuple`3.cs" />
     <Compile Include="Misc\Utils.cs" />
     <Compile Include="NoViableAltException.cs" />
     <Compile Include="Parser.cs" />
diff --git a/Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs b/Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs
deleted file mode 100644
index 98b75cad8..000000000
--- a/Antlr4.Runtime/Misc/AbstractEqualityComparator`1.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <summary>
-	/// This abstract base class is provided so performance-critical applications can
-	/// use virtual- instead of interface-dispatch when calling comparator methods.
-	/// </summary>
-	/// <remarks>
-	/// This abstract base class is provided so performance-critical applications can
-	/// use virtual- instead of interface-dispatch when calling comparator methods.
-	/// </remarks>
-	/// <author>Sam Harwell</author>
-	public abstract class AbstractEqualityComparator<T> : IEqualityComparator<T>
-	{
-		public abstract bool Equals(T arg1, T arg2);
-
-		public abstract int HashCode(T arg1);
-	}
-}
diff --git a/Antlr4.Runtime/Misc/IEqualityComparator`1.cs b/Antlr4.Runtime/Misc/IEqualityComparator`1.cs
deleted file mode 100644
index 9b6b58a7d..000000000
--- a/Antlr4.Runtime/Misc/IEqualityComparator`1.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <summary>
-	/// This interface provides an abstract concept of object equality independent of
-	/// <see cref="object.Equals(object)">object.Equals(object)</see>
-	/// (object equality) and the
-	/// <code>==</code>
-	/// operator
-	/// (reference equality). It can be used to provide algorithm-specific unordered
-	/// comparisons without requiring changes to the object itself.
-	/// </summary>
-	/// <author>Sam Harwell</author>
-	public interface IEqualityComparator<T>
-	{
-		/// <summary>This method returns a hash code for the specified object.</summary>
-		/// <remarks>This method returns a hash code for the specified object.</remarks>
-		/// <param name="obj">The object.</param>
-		/// <returns>
-		/// The hash code for
-		/// <code>obj</code>
-		/// .
-		/// </returns>
-		int HashCode(T obj);
-
-		/// <summary>This method tests if two objects are equal.</summary>
-		/// <remarks>This method tests if two objects are equal.</remarks>
-		/// <param name="a">The first object to compare.</param>
-		/// <param name="b">The second object to compare.</param>
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// if
-		/// <code>a</code>
-		/// equals
-		/// <code>b</code>
-		/// , otherwise
-		/// <code>false</code>
-		/// .
-		/// </returns>
-		bool Equals(T a, T b);
-	}
-}
diff --git a/Antlr4.Runtime/Misc/IntegerList.cs b/Antlr4.Runtime/Misc/IntegerList.cs
deleted file mode 100644
index a9fe4598c..000000000
--- a/Antlr4.Runtime/Misc/IntegerList.cs
+++ /dev/null
@@ -1,346 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <author>Sam Harwell</author>
-	public class IntegerList
-	{
-		private static int[] EmptyData = new int[0];
-
-		private const int InitialSize = 4;
-
-		private const int MaxArraySize = int.MaxValue - 8;
-
-		[NotNull]
-		private int[] _data;
-
-		private int _size;
-
-		public IntegerList()
-		{
-			_data = EmptyData;
-		}
-
-		public IntegerList(int capacity)
-		{
-			if (capacity < 0)
-			{
-				throw new ArgumentException();
-			}
-			if (capacity == 0)
-			{
-				_data = EmptyData;
-			}
-			else
-			{
-				_data = new int[capacity];
-			}
-		}
-
-		public IntegerList(Antlr4.Runtime.Misc.IntegerList list)
-		{
-			_data = list._data.Clone();
-			_size = list._size;
-		}
-
-		public IntegerList(ICollection<int> list) : this(list.Count)
-		{
-			foreach (int value in list)
-			{
-				Add(value);
-			}
-		}
-
-		public void Add(int value)
-		{
-			if (_data.Length == _size)
-			{
-				EnsureCapacity(_size + 1);
-			}
-			_data[_size] = value;
-			_size++;
-		}
-
-		public void AddAll(int[] array)
-		{
-			EnsureCapacity(_size + array.Length);
-			System.Array.Copy(array, 0, _data, _size, array.Length);
-			_size += array.Length;
-		}
-
-		public void AddAll(Antlr4.Runtime.Misc.IntegerList list)
-		{
-			EnsureCapacity(_size + list._size);
-			System.Array.Copy(list._data, 0, _data, _size, list._size);
-			_size += list._size;
-		}
-
-		public void AddAll(ICollection<int> list)
-		{
-			EnsureCapacity(_size + list.Count);
-			int current = 0;
-			foreach (int x in list)
-			{
-				_data[_size + current] = x;
-			}
-			_size += list.Count;
-		}
-
-		public int Get(int index)
-		{
-			if (index < 0 || index >= _size)
-			{
-				throw new IndexOutOfRangeException();
-			}
-			return _data[index];
-		}
-
-		public bool Contains(int value)
-		{
-			for (int i = 0; i < _size; i++)
-			{
-				if (_data[i] == value)
-				{
-					return true;
-				}
-			}
-			return false;
-		}
-
-		public int Set(int index, int value)
-		{
-			if (index < 0 || index >= _size)
-			{
-				throw new IndexOutOfRangeException();
-			}
-			int previous = _data[index];
-			_data[index] = value;
-			return previous;
-		}
-
-		public int RemoveAt(int index)
-		{
-			int value = Get(index);
-			System.Array.Copy(_data, index + 1, _data, index, _size - index - 1);
-			_data[_size - 1] = 0;
-			_size--;
-			return value;
-		}
-
-		public void RemoveRange(int fromIndex, int toIndex)
-		{
-			if (fromIndex < 0 || toIndex < 0 || fromIndex > _size || toIndex > _size)
-			{
-				throw new IndexOutOfRangeException();
-			}
-			if (fromIndex > toIndex)
-			{
-				throw new ArgumentException();
-			}
-			System.Array.Copy(_data, toIndex, _data, fromIndex, _size - toIndex);
-			Arrays.Fill(_data, _size - (toIndex - fromIndex), _size, 0);
-			_size -= (toIndex - fromIndex);
-		}
-
-		public bool IsEmpty()
-		{
-			return _size == 0;
-		}
-
-		public int Size()
-		{
-			return _size;
-		}
-
-		public void TrimToSize()
-		{
-			if (_data.Length == _size)
-			{
-				return;
-			}
-			_data = Arrays.CopyOf(_data, _size);
-		}
-
-		public void Clear()
-		{
-			Arrays.Fill(_data, 0, _size, 0);
-			_size = 0;
-		}
-
-		public int[] ToArray()
-		{
-			if (_size == 0)
-			{
-				return EmptyData;
-			}
-			return Arrays.CopyOf(_data, _size);
-		}
-
-		public void Sort()
-		{
-			Arrays.Sort(_data, 0, _size);
-		}
-
-		/// <summary>Compares the specified object with this list for equality.</summary>
-		/// <remarks>
-		/// Compares the specified object with this list for equality.  Returns
-		/// <code>true</code>
-		/// if and only if the specified object is also an
-		/// <see cref="IntegerList">IntegerList</see>
-		/// ,
-		/// both lists have the same size, and all corresponding pairs of elements in
-		/// the two lists are equal.  In other words, two lists are defined to be
-		/// equal if they contain the same elements in the same order.
-		/// <p>
-		/// This implementation first checks if the specified object is this
-		/// list. If so, it returns
-		/// <code>true</code>
-		/// ; if not, it checks if the
-		/// specified object is an
-		/// <see cref="IntegerList">IntegerList</see>
-		/// . If not, it returns
-		/// <code>false</code>
-		/// ;
-		/// if so, it checks the size of both lists. If the lists are not the same size,
-		/// it returns
-		/// <code>false</code>
-		/// ; otherwise it iterates over both lists, comparing
-		/// corresponding pairs of elements.  If any comparison returns
-		/// <code>false</code>
-		/// ,
-		/// this method returns
-		/// <code>false</code>
-		/// .
-		/// </remarks>
-		/// <param name="o">the object to be compared for equality with this list</param>
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// if the specified object is equal to this list
-		/// </returns>
-		public override bool Equals(object o)
-		{
-			if (o == this)
-			{
-				return true;
-			}
-			if (!(o is Antlr4.Runtime.Misc.IntegerList))
-			{
-				return false;
-			}
-			Antlr4.Runtime.Misc.IntegerList other = (Antlr4.Runtime.Misc.IntegerList)o;
-			if (_size != other._size)
-			{
-				return false;
-			}
-			for (int i = 0; i < _size; i++)
-			{
-				if (_data[i] != other._data[i])
-				{
-					return false;
-				}
-			}
-			return true;
-		}
-
-		/// <summary>Returns the hash code value for this list.</summary>
-		/// <remarks>
-		/// Returns the hash code value for this list.
-		/// <p/>
-		/// This implementation uses exactly the code that is used to define the
-		/// list hash function in the documentation for the
-		/// <see cref="System.Collections.IList{E}.GetHashCode()">System.Collections.IList&lt;E&gt;.GetHashCode()
-		/// 	</see>
-		/// method.
-		/// </remarks>
-		/// <returns>the hash code value for this list</returns>
-		public override int GetHashCode()
-		{
-			int hashCode = 1;
-			for (int i = 0; i < _size; i++)
-			{
-				hashCode = 31 * hashCode + _data[i];
-			}
-			return hashCode;
-		}
-
-		/// <summary>Returns a string representation of this list.</summary>
-		/// <remarks>Returns a string representation of this list.</remarks>
-		public override string ToString()
-		{
-			return Arrays.ToString(ToArray());
-		}
-
-		public int BinarySearch(int key)
-		{
-			return System.Array.BinarySearch(_data, 0, _size, key);
-		}
-
-		public int BinarySearch(int fromIndex, int toIndex, int key)
-		{
-			if (fromIndex < 0 || toIndex < 0 || fromIndex > _size || toIndex > _size)
-			{
-				throw new IndexOutOfRangeException();
-			}
-			return System.Array.BinarySearch(_data, fromIndex, toIndex, key);
-		}
-
-		private void EnsureCapacity(int capacity)
-		{
-			if (capacity < 0 || capacity > MaxArraySize)
-			{
-				throw new OutOfMemoryException();
-			}
-			int newLength;
-			if (_data.Length == 0)
-			{
-				newLength = InitialSize;
-			}
-			else
-			{
-				newLength = _data.Length;
-			}
-			while (newLength < capacity)
-			{
-				newLength = newLength * 2;
-				if (newLength < 0 || newLength > MaxArraySize)
-				{
-					newLength = MaxArraySize;
-				}
-			}
-			_data = Arrays.CopyOf(_data, newLength);
-		}
-	}
-}
diff --git a/Antlr4.Runtime/Misc/IntegerStack.cs b/Antlr4.Runtime/Misc/IntegerStack.cs
deleted file mode 100644
index ee5ad07cf..000000000
--- a/Antlr4.Runtime/Misc/IntegerStack.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <author>Sam Harwell</author>
-	public class IntegerStack : IntegerList
-	{
-		public IntegerStack()
-		{
-		}
-
-		public IntegerStack(int capacity) : base(capacity)
-		{
-		}
-
-		public IntegerStack(Antlr4.Runtime.Misc.IntegerStack list) : base(list)
-		{
-		}
-
-		public void Push(int value)
-		{
-			Add(value);
-		}
-
-		public int Pop()
-		{
-			return RemoveAt(Size() - 1);
-		}
-
-		public int Peek()
-		{
-			return Get(Size() - 1);
-		}
-	}
-}
diff --git a/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs b/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
deleted file mode 100644
index cd35f8632..000000000
--- a/Antlr4.Runtime/Misc/ObjectEqualityComparator.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <summary>
-	/// This default implementation of
-	/// <see cref="IEqualityComparator{T}">IEqualityComparator&lt;T&gt;</see>
-	/// uses object equality
-	/// for comparisons by calling
-	/// <see cref="object.GetHashCode()">object.GetHashCode()</see>
-	/// and
-	/// <see cref="object.Equals(object)">object.Equals(object)</see>
-	/// .
-	/// </summary>
-	/// <author>Sam Harwell</author>
-	public sealed class ObjectEqualityComparator : AbstractEqualityComparator<object>
-	{
-		public static readonly ObjectEqualityComparator Instance = new ObjectEqualityComparator
-			();
-
-		/// <summary>
-		/// <inheritDoc></inheritDoc>
-		/// <p/>
-		/// This implementation returns
-		/// <code>obj.</code>
-		/// <see cref="object.GetHashCode()">hashCode()</see>
-		/// .
-		/// </summary>
-		public override int HashCode(object obj)
-		{
-			if (obj == null)
-			{
-				return 0;
-			}
-			return obj.GetHashCode();
-		}
-
-		/// <summary>
-		/// <inheritDoc></inheritDoc>
-		/// <p/>
-		/// This implementation relies on object equality. If both objects are
-		/// <code>null</code>
-		/// , this method returns
-		/// <code>true</code>
-		/// . Otherwise if only
-		/// <code>a</code>
-		/// is
-		/// <code>null</code>
-		/// , this method returns
-		/// <code>false</code>
-		/// . Otherwise,
-		/// this method returns the result of
-		/// <code>a.</code>
-		/// <see cref="object.Equals(object)">equals</see>
-		/// <code>(b)</code>
-		/// .
-		/// </summary>
-		public override bool Equals(object a, object b)
-		{
-			if (a == null)
-			{
-				return b == null;
-			}
-			return a.Equals(b);
-		}
-	}
-}
diff --git a/Antlr4.Runtime/Misc/Tuple.cs b/Antlr4.Runtime/Misc/Tuple.cs
deleted file mode 100644
index 4dcc9f258..000000000
--- a/Antlr4.Runtime/Misc/Tuple.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <author>Sam Harwell</author>
-	public sealed class Tuple
-	{
-		public static System.Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
-		{
-			return new System.Tuple<T1, T2>(item1, item2);
-		}
-
-		public static System.Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 
-			item3)
-		{
-			return new System.Tuple<T1, T2, T3>(item1, item2, item3);
-		}
-
-		internal static bool Equals(object x, object y)
-		{
-			return x == y || (x != null && x.Equals(y));
-		}
-
-		public Tuple()
-		{
-		}
-		// static utility class
-	}
-}
diff --git a/Antlr4.Runtime/Misc/Tuple`2.cs b/Antlr4.Runtime/Misc/Tuple`2.cs
deleted file mode 100644
index 34e647d2b..000000000
--- a/Antlr4.Runtime/Misc/Tuple`2.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <author>Sam Harwell</author>
-	public class Tuple<T1, T2>
-	{
-		private readonly T1 item1;
-
-		private readonly T2 item2;
-
-		public Tuple(T1 item1, T2 item2)
-		{
-			this.item1 = item1;
-			this.item2 = item2;
-		}
-
-		public T1 GetItem1()
-		{
-			return item1;
-		}
-
-		public T2 GetItem2()
-		{
-			return item2;
-		}
-
-		public override bool Equals(object obj)
-		{
-			if (obj == this)
-			{
-				return true;
-			}
-			else
-			{
-				if (!(obj is Tuple<object, object>))
-				{
-					return false;
-				}
-			}
-			Tuple<object, object> other = (Tuple<object, object>)obj;
-			return Tuple.Equals(this.item1, other.item1) && Tuple.Equals(this.item2, other.item2
-				);
-		}
-
-		public override int GetHashCode()
-		{
-			int hash = 5;
-			hash = 79 * hash + (this.item1 != null ? this.item1.GetHashCode() : 0);
-			hash = 79 * hash + (this.item2 != null ? this.item2.GetHashCode() : 0);
-			return hash;
-		}
-	}
-}
diff --git a/Antlr4.Runtime/Misc/Tuple`3.cs b/Antlr4.Runtime/Misc/Tuple`3.cs
deleted file mode 100644
index 41186b700..000000000
--- a/Antlr4.Runtime/Misc/Tuple`3.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * [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 Sharpen;
-
-namespace Antlr4.Runtime.Misc
-{
-	/// <author>Sam Harwell</author>
-	public class Tuple<T1, T2, T3>
-	{
-		private readonly T1 item1;
-
-		private readonly T2 item2;
-
-		private readonly T3 item3;
-
-		public Tuple(T1 item1, T2 item2, T3 item3)
-		{
-			this.item1 = item1;
-			this.item2 = item2;
-			this.item3 = item3;
-		}
-
-		public T1 GetItem1()
-		{
-			return item1;
-		}
-
-		public T2 GetItem2()
-		{
-			return item2;
-		}
-
-		public T3 GetItem3()
-		{
-			return item3;
-		}
-
-		public override bool Equals(object obj)
-		{
-			if (obj == this)
-			{
-				return true;
-			}
-			else
-			{
-				if (!(obj is Tuple<object, object, object>))
-				{
-					return false;
-				}
-			}
-			Tuple<object, object, object> other = (Tuple<object, object, object>)obj;
-			return Tuple.Equals(this.item1, other.item1) && Tuple.Equals(this.item2, other.item2
-				) && Tuple.Equals(this.item3, other.item3);
-		}
-
-		public override int GetHashCode()
-		{
-			int hash = 5;
-			hash = 79 * hash + (this.item1 != null ? this.item1.GetHashCode() : 0);
-			hash = 79 * hash + (this.item2 != null ? this.item2.GetHashCode() : 0);
-			hash = 79 * hash + (this.item3 != null ? this.item3.GetHashCode() : 0);
-			return hash;
-		}
-	}
-}
diff --git a/Antlr4.Runtime/Misc/Utils.cs b/Antlr4.Runtime/Misc/Utils.cs
index b9d32a2e4..e02f941a2 100644
--- a/Antlr4.Runtime/Misc/Utils.cs
+++ b/Antlr4.Runtime/Misc/Utils.cs
@@ -27,57 +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.
  */
-using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Text;
 using Antlr4.Runtime.Misc;
-using Java.Awt;
-using Java.Awt.Event;
 using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
 	public class Utils
 	{
-		public static string Join<_T0>(IEnumerable<_T0> iter, string separator)
-		{
-			return Join(iter.GetEnumerator(), separator);
-		}
-
-		public static string Join<T>(T[] array, string separator)
-		{
-			return Join(Arrays.AsList(array), separator);
-		}
-
-		// Seriously: why isn't this built in to java? ugh!
-		public static string Join<T>(IEnumerator<T> iter, string separator)
-		{
-			StringBuilder buf = new StringBuilder();
-			while (iter.HasNext())
-			{
-				buf.Append(iter.Next());
-				if (iter.HasNext())
-				{
-					buf.Append(separator);
-				}
-			}
-			return buf.ToString();
-		}
-
-		public static bool Equals(object x, object y)
-		{
-			if (x == y)
-			{
-				return true;
-			}
-			if (x == null || y == null)
-			{
-				return false;
-			}
-			return x.Equals(y);
-		}
-
 		public static int NumNonnull(object[] data)
 		{
 			int n = 0;
@@ -145,15 +103,6 @@ namespace Antlr4.Runtime.Misc
 			return buf.ToString();
 		}
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public static void WriteFile(string fileName, string content)
-		{
-			FileWriter fw = new FileWriter(fileName);
-			TextWriter w = new BufferedWriter(fw);
-			w.Write(content);
-			w.Close();
-		}
-
 		public static void RemoveAll<T, _T1>(IList<T> list, IPredicate<_T1> predicate)
 		{
 			int j = 0;
@@ -192,67 +141,5 @@ namespace Antlr4.Runtime.Misc
 				}
 			}
 		}
-
-		/// <exception cref="System.Exception"></exception>
-		public static void WaitForClose(Window window)
-		{
-			object Lock = new object();
-			Sharpen.Thread t = new _Thread_146(Lock, window);
-			t.Start();
-			window.AddWindowListener(new _WindowAdapter_162(Lock, window));
-			t.Join();
-		}
-
-		private sealed class _Thread_146 : Sharpen.Thread
-		{
-			public _Thread_146(object Lock, Window window)
-			{
-				this.Lock = Lock;
-				this.window = window;
-			}
-
-			public override void Run()
-			{
-				lock (Lock)
-				{
-					while (window.IsVisible())
-					{
-						try
-						{
-							Sharpen.Runtime.Wait(Lock, 500);
-						}
-						catch (Exception)
-						{
-						}
-					}
-				}
-			}
-
-			private readonly object Lock;
-
-			private readonly Window window;
-		}
-
-		private sealed class _WindowAdapter_162 : WindowAdapter
-		{
-			public _WindowAdapter_162(object Lock, Window window)
-			{
-				this.Lock = Lock;
-				this.window = window;
-			}
-
-			public override void WindowClosing(WindowEvent arg0)
-			{
-				lock (Lock)
-				{
-					window.SetVisible(false);
-					Sharpen.Runtime.Notify(Lock);
-				}
-			}
-
-			private readonly object Lock;
-
-			private readonly Window window;
-		}
 	}
 }
diff --git a/reference/antlr4 b/reference/antlr4
index ad17f36a4..c7dc3828f 160000
--- a/reference/antlr4
+++ b/reference/antlr4
@@ -1 +1 @@
-Subproject commit ad17f36a468eb693df02676fa108567bcd319c5a
+Subproject commit c7dc3828fc49781d3015565db387f37c38137ee6

From 8007bf40123cf4a5aa2c88cbf97fc6340fddd5aa Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Fri, 15 Feb 2013 16:41:52 -0600
Subject: [PATCH 06/10] Fix case of file names in project

---
 Antlr4.Runtime/Antlr4.Runtime.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Antlr4.Runtime/Antlr4.Runtime.csproj b/Antlr4.Runtime/Antlr4.Runtime.csproj
index ffa35b47e..4bc5d3780 100644
--- a/Antlr4.Runtime/Antlr4.Runtime.csproj
+++ b/Antlr4.Runtime/Antlr4.Runtime.csproj
@@ -39,8 +39,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ANTLRFileStream.cs" />
-    <Compile Include="ANTLRInputStream.cs" />
+    <Compile Include="AntlrFileStream.cs" />
+    <Compile Include="AntlrInputStream.cs" />
     <Compile Include="Atn\AbstractPredicateTransition.cs" />
     <Compile Include="Atn\ActionTransition.cs" />
     <Compile Include="Atn\ArrayPredictionContext.cs" />

From 8ab7c204116b028e276833386c1a8e6e5c963a19 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Sat, 16 Feb 2013 08:09:48 -0600
Subject: [PATCH 07/10] Generate several properties in place of methods

---
 Antlr4.Runtime/ANTLRFileStream.cs             |   7 +-
 Antlr4.Runtime/ANTLRInputStream.cs            |  21 +-
 Antlr4.Runtime/Atn/ATNConfig.cs               |  10 +-
 Antlr4.Runtime/Atn/ATNSimulator.cs            |  18 +-
 Antlr4.Runtime/Atn/ATNState.cs                |   4 +-
 Antlr4.Runtime/Atn/ActionTransition.cs        |  14 +-
 Antlr4.Runtime/Atn/ArrayPredictionContext.cs  |  51 +++--
 Antlr4.Runtime/Atn/AtomTransition.cs          |  15 +-
 Antlr4.Runtime/Atn/EmptyPredictionContext.cs  |  21 +-
 Antlr4.Runtime/Atn/EpsilonTransition.cs       |  14 +-
 Antlr4.Runtime/Atn/LL1Analyzer.cs             |  10 +-
 Antlr4.Runtime/Atn/LexerATNSimulator.cs       |  25 ++-
 Antlr4.Runtime/Atn/NotSetTransition.cs        |   7 +-
 Antlr4.Runtime/Atn/ParserATNSimulator.cs      |  66 +++----
 .../Atn/PrecedencePredicateTransition.cs      |  14 +-
 Antlr4.Runtime/Atn/PredicateTransition.cs     |  14 +-
 Antlr4.Runtime/Atn/PredictionContext.cs       |  43 ++--
 Antlr4.Runtime/Atn/PredictionContextCache.cs  |  14 +-
 Antlr4.Runtime/Atn/RangeTransition.cs         |  15 +-
 Antlr4.Runtime/Atn/RuleTransition.cs          |  14 +-
 Antlr4.Runtime/Atn/SetTransition.cs           |  15 +-
 .../Atn/SingletonPredictionContext.cs         |  21 +-
 Antlr4.Runtime/Atn/Transition.cs              |  24 ++-
 Antlr4.Runtime/Atn/WildcardTransition.cs      |   7 +-
 Antlr4.Runtime/BailErrorStrategy.cs           |   4 +-
 Antlr4.Runtime/BufferedTokenStream.cs         |  62 +++---
 Antlr4.Runtime/CommonToken.cs                 | 184 ++++++++++--------
 Antlr4.Runtime/CommonTokenFactory.cs          |   8 +-
 Antlr4.Runtime/CommonTokenStream.cs           |   4 +-
 Antlr4.Runtime/DefaultErrorStrategy.cs        |  24 +--
 Antlr4.Runtime/Dfa/DFASerializer.cs           |   8 +-
 Antlr4.Runtime/Dfa/DFAState.cs                |  63 +++---
 Antlr4.Runtime/IIntStream.cs                  |  19 +-
 Antlr4.Runtime/IToken.cs                      |  56 ++++--
 Antlr4.Runtime/ITokenSource.cs                |  28 ++-
 Antlr4.Runtime/ITokenStream.cs                |   8 +-
 Antlr4.Runtime/IWritableToken.cs              |  30 ++-
 Antlr4.Runtime/Lexer.cs                       |  54 +++--
 Antlr4.Runtime/LexerNoViableAltException.cs   |   2 +-
 .../Misc/RuleDependencyProcessor.cs           |   2 +-
 Antlr4.Runtime/Parser.cs                      |  30 +--
 Antlr4.Runtime/ParserRuleContext.cs           |  33 ++--
 Antlr4.Runtime/Recognizer`2.cs                |  10 +-
 Antlr4.Runtime/RuleContext.cs                 |  41 ++--
 Antlr4.Runtime/TokenStreamRewriter.cs         |  30 +--
 .../Tree/AbstractParseTreeVisitor`1.cs        |   2 +-
 Antlr4.Runtime/Tree/IParseTree.cs             |   7 +-
 Antlr4.Runtime/Tree/IRuleNode.cs              |  11 +-
 Antlr4.Runtime/Tree/ISyntaxTree.cs            |   6 +-
 Antlr4.Runtime/Tree/ITerminalNode.cs          |  10 +-
 Antlr4.Runtime/Tree/ITree.cs                  |  15 +-
 Antlr4.Runtime/Tree/ParseTreeWalker.cs        |   6 +-
 Antlr4.Runtime/Tree/TerminalNodeImpl.cs       |  65 ++++---
 Antlr4.Runtime/Tree/Trees.cs                  |  22 +--
 Antlr4.Runtime/UnbufferedCharStream.cs        |  21 +-
 Antlr4.Runtime/UnbufferedTokenStream.cs       |  42 ++--
 reference/antlr4                              |   2 +-
 57 files changed, 853 insertions(+), 520 deletions(-)

diff --git a/Antlr4.Runtime/ANTLRFileStream.cs b/Antlr4.Runtime/ANTLRFileStream.cs
index 857b764f6..4e295d7d1 100644
--- a/Antlr4.Runtime/ANTLRFileStream.cs
+++ b/Antlr4.Runtime/ANTLRFileStream.cs
@@ -88,9 +88,12 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		public override string GetSourceName()
+		public override string SourceName
 		{
-			return fileName;
+			get
+			{
+				return fileName;
+			}
 		}
 	}
 }
diff --git a/Antlr4.Runtime/ANTLRInputStream.cs b/Antlr4.Runtime/ANTLRInputStream.cs
index 0bcc8377f..2b032a116 100644
--- a/Antlr4.Runtime/ANTLRInputStream.cs
+++ b/Antlr4.Runtime/ANTLRInputStream.cs
@@ -233,14 +233,20 @@ namespace Antlr4.Runtime
 		/// last symbol has been read.  The index is the index of char to
 		/// be returned from LA(1).
 		/// </remarks>
-		public virtual int Index()
+		public virtual int Index
 		{
-			return p;
+			get
+			{
+				return p;
+			}
 		}
 
-		public virtual int Size()
+		public virtual int Size
 		{
-			return n;
+			get
+			{
+				return n;
+			}
 		}
 
 		/// <summary>mark/release do nothing; we have entire buffer</summary>
@@ -295,9 +301,12 @@ namespace Antlr4.Runtime
 			return new string(data, start, count);
 		}
 
-		public virtual string GetSourceName()
+		public virtual string SourceName
 		{
-			return name;
+			get
+			{
+				return name;
+			}
 		}
 
 		public override string ToString()
diff --git a/Antlr4.Runtime/Atn/ATNConfig.cs b/Antlr4.Runtime/Atn/ATNConfig.cs
index 14f69e87f..8b7d99638 100644
--- a/Antlr4.Runtime/Atn/ATNConfig.cs
+++ b/Antlr4.Runtime/Atn/ATNConfig.cs
@@ -305,17 +305,17 @@ namespace Antlr4.Runtime.Atn
 				{
 					return true;
 				}
-				if (left.Size() < right.Size())
+				if (left.Size < right.Size)
 				{
 					return false;
 				}
-				if (right.IsEmpty())
+				if (right.IsEmpty)
 				{
-					return left.HasEmpty();
+					return left.HasEmpty;
 				}
 				else
 				{
-					for (int i = 0; i < right.Size(); i++)
+					for (int i = 0; i < right.Size; i++)
 					{
 						int index = left.FindReturnState(right.GetReturnState(i));
 						if (index < 0)
@@ -394,7 +394,7 @@ namespace Antlr4.Runtime.Atn
 			while (!workList.IsEmpty())
 			{
 				PredictionContext current = workList.Pop();
-				for (int i = 0; i < current.Size(); i++)
+				for (int i = 0; i < current.Size; i++)
 				{
 					builder.Append("  s").Append(Sharpen.Runtime.IdentityHashCode(current));
 					builder.Append("->");
diff --git a/Antlr4.Runtime/Atn/ATNSimulator.cs b/Antlr4.Runtime/Atn/ATNSimulator.cs
index ca568fb43..b9637ea18 100644
--- a/Antlr4.Runtime/Atn/ATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ATNSimulator.cs
@@ -444,7 +444,7 @@ namespace Antlr4.Runtime.Atn
 				RuleStartState startState = atn.ruleToStartState[i];
 				ATNState middleState = startState;
 				while (middleState.OnlyHasEpsilonTransitions() && middleState.GetNumberOfOptimizedTransitions
-					() == 1 && middleState.GetOptimizedTransition(0).GetSerializationType() == Transition
+					() == 1 && middleState.GetOptimizedTransition(0).SerializationType == Transition
 					.Epsilon)
 				{
 					middleState = middleState.GetOptimizedTransition(0).target;
@@ -455,13 +455,13 @@ namespace Antlr4.Runtime.Atn
 				}
 				Transition matchTransition = middleState.GetOptimizedTransition(0);
 				ATNState matchTarget = matchTransition.target;
-				if (matchTransition.IsEpsilon() || !matchTarget.OnlyHasEpsilonTransitions() || matchTarget
+				if (matchTransition.IsEpsilon || !matchTarget.OnlyHasEpsilonTransitions() || matchTarget
 					.GetNumberOfOptimizedTransitions() != 1 || !(matchTarget.GetOptimizedTransition(
 					0).target is RuleStopState))
 				{
 					continue;
 				}
-				switch (matchTransition.GetSerializationType())
+				switch (matchTransition.SerializationType)
 				{
 					case Transition.Atom:
 					case Transition.Range:
@@ -529,7 +529,7 @@ namespace Antlr4.Runtime.Atn
 					intermediateState.SetRuleIndex(target.ruleIndex);
 					atn.AddState(intermediateState);
 					optimizedTransitions.AddItem(new EpsilonTransition(intermediateState));
-					switch (effective.GetSerializationType())
+					switch (effective.SerializationType)
 					{
 						case Transition.Atom:
 						{
@@ -547,7 +547,7 @@ namespace Antlr4.Runtime.Atn
 
 						case Transition.Set:
 						{
-							intermediateState.AddTransition(new SetTransition(target, effective.Label()));
+							intermediateState.AddTransition(new SetTransition(target, effective.Label));
 							break;
 						}
 
@@ -589,7 +589,7 @@ namespace Antlr4.Runtime.Atn
 				{
 					Transition transition = state.GetOptimizedTransition(i);
 					ATNState intermediate = transition.target;
-					if (transition.GetSerializationType() != Transition.Epsilon || intermediate.GetStateType
+					if (transition.SerializationType != Transition.Epsilon || intermediate.GetStateType
 						() != ATNState.Basic || !intermediate.OnlyHasEpsilonTransitions())
 					{
 						if (optimizedTransitions != null)
@@ -600,7 +600,7 @@ namespace Antlr4.Runtime.Atn
 					}
 					for (int j = 0; j < intermediate.GetNumberOfOptimizedTransitions(); j++)
 					{
-						if (intermediate.GetOptimizedTransition(j).GetSerializationType() != Transition.Epsilon)
+						if (intermediate.GetOptimizedTransition(j).SerializationType != Transition.Epsilon)
 						{
 							if (optimizedTransitions != null)
 							{
@@ -712,7 +712,7 @@ nextState_break: ;
 						}
 						else
 						{
-							matchSet.AddAll(matchTransition.Label());
+							matchSet.AddAll(matchTransition.Label);
 						}
 					}
 				}
@@ -821,7 +821,7 @@ nextState_break: ;
 					.transitions;
 				foreach (Transition t in transitions)
 				{
-					if (t.GetSerializationType() != Transition.Epsilon)
+					if (t.SerializationType != Transition.Epsilon)
 					{
 						return false;
 					}
diff --git a/Antlr4.Runtime/Atn/ATNState.cs b/Antlr4.Runtime/Atn/ATNState.cs
index 256b7397c..ec21b38d6 100644
--- a/Antlr4.Runtime/Atn/ATNState.cs
+++ b/Antlr4.Runtime/Atn/ATNState.cs
@@ -212,11 +212,11 @@ namespace Antlr4.Runtime.Atn
 		{
 			if (transitions.IsEmpty())
 			{
-				epsilonOnlyTransitions = e.IsEpsilon();
+				epsilonOnlyTransitions = e.IsEpsilon;
 			}
 			else
 			{
-				if (epsilonOnlyTransitions != e.IsEpsilon())
+				if (epsilonOnlyTransitions != e.IsEpsilon)
 				{
 					System.Console.Error.Format("ATN state %d has both epsilon and non-epsilon transitions.\n"
 						, stateNumber);
diff --git a/Antlr4.Runtime/Atn/ActionTransition.cs b/Antlr4.Runtime/Atn/ActionTransition.cs
index b21d4e5d8..0668bbf73 100644
--- a/Antlr4.Runtime/Atn/ActionTransition.cs
+++ b/Antlr4.Runtime/Atn/ActionTransition.cs
@@ -54,14 +54,20 @@ namespace Antlr4.Runtime.Atn
 			this.isCtxDependent = isCtxDependent;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Action;
+			get
+			{
+				return Action;
+			}
 		}
 
-		public override bool IsEpsilon()
+		public override bool IsEpsilon
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
 		// we are to be ignored by analysis 'cept for predicates
diff --git a/Antlr4.Runtime/Atn/ArrayPredictionContext.cs b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
index 133282b8a..9142be4a4 100644
--- a/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
@@ -79,24 +79,33 @@ namespace Antlr4.Runtime.Atn
 			return System.Array.BinarySearch(returnStates, returnState);
 		}
 
-		public override int Size()
+		public override int Size
 		{
-			return returnStates.Length;
+			get
+			{
+				return returnStates.Length;
+			}
 		}
 
-		public override bool IsEmpty()
+		public override bool IsEmpty
 		{
-			return false;
+			get
+			{
+				return false;
+			}
 		}
 
-		public override bool HasEmpty()
+		public override bool HasEmpty
 		{
-			return returnStates[returnStates.Length - 1] == EmptyFullStateKey;
+			get
+			{
+				return returnStates[returnStates.Length - 1] == EmptyFullStateKey;
+			}
 		}
 
 		protected internal override PredictionContext AddEmptyContext()
 		{
-			if (HasEmpty())
+			if (HasEmpty)
 			{
 				return this;
 			}
@@ -109,7 +118,7 @@ namespace Antlr4.Runtime.Atn
 
 		protected internal override PredictionContext RemoveEmptyContext()
 		{
-			if (!HasEmpty())
+			if (!HasEmpty)
 			{
 				return this;
 			}
@@ -134,11 +143,11 @@ namespace Antlr4.Runtime.Atn
 		private static PredictionContext AppendContext(PredictionContext context, PredictionContext
 			 suffix, PredictionContext.IdentityHashMap visited)
 		{
-			if (suffix.IsEmpty())
+			if (suffix.IsEmpty)
 			{
 				if (IsEmptyLocal(suffix))
 				{
-					if (context.HasEmpty())
+					if (context.HasEmpty)
 					{
 						return EmptyLocal;
 					}
@@ -146,21 +155,21 @@ namespace Antlr4.Runtime.Atn
 				}
 				return context;
 			}
-			if (suffix.Size() != 1)
+			if (suffix.Size != 1)
 			{
 				throw new NotSupportedException("Appending a tree suffix is not yet supported.");
 			}
 			PredictionContext result = visited.Get(context);
 			if (result == null)
 			{
-				if (context.IsEmpty())
+				if (context.IsEmpty)
 				{
 					result = suffix;
 				}
 				else
 				{
-					int parentCount = context.Size();
-					if (context.HasEmpty())
+					int parentCount = context.Size;
+					if (context.HasEmpty)
 					{
 						parentCount--;
 					}
@@ -185,7 +194,7 @@ namespace Antlr4.Runtime.Atn
 						result = new Antlr4.Runtime.Atn.ArrayPredictionContext(updatedParents, updatedReturnStates
 							);
 					}
-					if (context.HasEmpty())
+					if (context.HasEmpty)
 					{
 						result = PredictionContext.Join(result, suffix);
 					}
@@ -235,28 +244,28 @@ namespace Antlr4.Runtime.Atn
 				{
 					continue;
 				}
-				int selfSize = operands.GetX().Size();
+				int selfSize = operands.X.Size;
 				if (selfSize == 0)
 				{
-					if (!operands.GetX().Equals(operands.GetY()))
+					if (!operands.X.Equals(operands.Y))
 					{
 						return false;
 					}
 					continue;
 				}
-				int otherSize = operands.GetY().Size();
+				int otherSize = operands.Y.Size;
 				if (selfSize != otherSize)
 				{
 					return false;
 				}
 				for (int i = 0; i < selfSize; i++)
 				{
-					if (operands.GetX().GetReturnState(i) != operands.GetY().GetReturnState(i))
+					if (operands.X.GetReturnState(i) != operands.Y.GetReturnState(i))
 					{
 						return false;
 					}
-					PredictionContext selfParent = operands.GetX().GetParent(i);
-					PredictionContext otherParent = operands.GetY().GetParent(i);
+					PredictionContext selfParent = operands.X.GetParent(i);
+					PredictionContext otherParent = operands.Y.GetParent(i);
 					if (selfParent.GetHashCode() != otherParent.GetHashCode())
 					{
 						return false;
diff --git a/Antlr4.Runtime/Atn/AtomTransition.cs b/Antlr4.Runtime/Atn/AtomTransition.cs
index 8b496c3b1..826db46dd 100644
--- a/Antlr4.Runtime/Atn/AtomTransition.cs
+++ b/Antlr4.Runtime/Atn/AtomTransition.cs
@@ -45,15 +45,20 @@ namespace Antlr4.Runtime.Atn
 			this.label = label;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Atom;
+			get
+			{
+				return Atom;
+			}
 		}
 
-		[NotNull]
-		public override IntervalSet Label()
+		public override IntervalSet Label
 		{
-			return IntervalSet.Of(label);
+			get
+			{
+				return IntervalSet.Of(label);
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
index bb5daebd3..e3a9e63bf 100644
--- a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
@@ -80,9 +80,12 @@ namespace Antlr4.Runtime.Atn
 			return -1;
 		}
 
-		public override int Size()
+		public override int Size
 		{
-			return 0;
+			get
+			{
+				return 0;
+			}
 		}
 
 		public override PredictionContext AppendContext(int returnContext, PredictionContextCache
@@ -97,14 +100,20 @@ namespace Antlr4.Runtime.Atn
 			return suffix;
 		}
 
-		public override bool IsEmpty()
+		public override bool IsEmpty
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
-		public override bool HasEmpty()
+		public override bool HasEmpty
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
 		public override bool Equals(object o)
diff --git a/Antlr4.Runtime/Atn/EpsilonTransition.cs b/Antlr4.Runtime/Atn/EpsilonTransition.cs
index dfac1c386..d5c3fcd65 100644
--- a/Antlr4.Runtime/Atn/EpsilonTransition.cs
+++ b/Antlr4.Runtime/Atn/EpsilonTransition.cs
@@ -39,14 +39,20 @@ namespace Antlr4.Runtime.Atn
 		{
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Epsilon;
+			get
+			{
+				return Epsilon;
+			}
 		}
 
-		public override bool IsEpsilon()
+		public override bool IsEpsilon
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/LL1Analyzer.cs b/Antlr4.Runtime/Atn/LL1Analyzer.cs
index 10975f632..926b868bd 100644
--- a/Antlr4.Runtime/Atn/LL1Analyzer.cs
+++ b/Antlr4.Runtime/Atn/LL1Analyzer.cs
@@ -155,19 +155,19 @@ namespace Antlr4.Runtime.Atn
 				}
 				else
 				{
-					if (ctx.IsEmpty() && addEOF)
+					if (ctx.IsEmpty && addEOF)
 					{
 						look.Add(IToken.Eof);
 						return;
 					}
 				}
-				for (int i = 0; i < ctx.Size(); i++)
+				for (int i = 0; i < ctx.Size; i++)
 				{
 					if (ctx.GetReturnState(i) != PredictionContext.EmptyFullStateKey)
 					{
 						ATNState returnState = atn.states[ctx.GetReturnState(i)];
 						//			System.out.println("popping back to "+retState);
-						for (int j = 0; j < ctx.Size(); j++)
+						for (int j = 0; j < ctx.Size; j++)
 						{
 							Look(returnState, ctx.GetParent(j), look, lookBusy, seeThruPreds, addEOF);
 						}
@@ -200,7 +200,7 @@ namespace Antlr4.Runtime.Atn
 					}
 					else
 					{
-						if (t.IsEpsilon())
+						if (t.IsEpsilon)
 						{
 							Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
 						}
@@ -213,7 +213,7 @@ namespace Antlr4.Runtime.Atn
 							else
 							{
 								//				System.out.println("adding "+ t);
-								IntervalSet set = t.Label();
+								IntervalSet set = t.Label;
 								if (set != null)
 								{
 									if (t is NotSetTransition)
diff --git a/Antlr4.Runtime/Atn/LexerATNSimulator.cs b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
index ffbbfbf50..72656715d 100644
--- a/Antlr4.Runtime/Atn/LexerATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
@@ -139,7 +139,7 @@ namespace Antlr4.Runtime.Atn
 			int mark = input.Mark();
 			try
 			{
-				this.startIndex = input.Index();
+				this.startIndex = input.Index;
 				this.prevAccept.Reset();
 				DFAState s0 = atn.modeToDFA[mode].s0.Get();
 				if (s0 == null)
@@ -282,7 +282,7 @@ namespace Antlr4.Runtime.Atn
 			else
 			{
 				// if no accept and EOF is first char, return EOF
-				if (t == IIntStream.Eof && input.Index() == startIndex)
+				if (t == IIntStream.Eof && input.Index == startIndex)
 				{
 					return IToken.Eof;
 				}
@@ -400,20 +400,20 @@ namespace Antlr4.Runtime.Atn
 			if (config.GetState() is RuleStopState)
 			{
 				PredictionContext context = config.GetContext();
-				if (context.IsEmpty())
+				if (context.IsEmpty)
 				{
 					configs.AddItem(config);
 					return true;
 				}
 				else
 				{
-					if (context.HasEmpty())
+					if (context.HasEmpty)
 					{
 						configs.AddItem(config.Transform(config.GetState(), PredictionContext.EmptyFull));
 						return true;
 					}
 				}
-				for (int i = 0; i < context.Size(); i++)
+				for (int i = 0; i < context.Size; i++)
 				{
 					int returnStateNumber = context.GetReturnState(i);
 					if (returnStateNumber == PredictionContext.EmptyFullStateKey)
@@ -458,13 +458,13 @@ namespace Antlr4.Runtime.Atn
 			 t, ATNConfigSet configs, bool speculative)
 		{
 			ATNConfig c;
-			switch (t.GetSerializationType())
+			switch (t.SerializationType)
 			{
 				case Transition.Rule:
 				{
 					RuleTransition ruleTransition = (RuleTransition)t;
 					if (optimize_tail_calls && ruleTransition.optimizedTailCall && !config.GetContext
-						().HasEmpty())
+						().HasEmpty)
 					{
 						c = config.Transform(t.target);
 					}
@@ -539,11 +539,10 @@ namespace Antlr4.Runtime.Atn
 		/// sensitive values, including
 		/// <see cref="Antlr4.Runtime.Lexer.GetText()">Antlr4.Runtime.Lexer.GetText()</see>
 		/// ,
-		/// <see cref="Antlr4.Runtime.Lexer.GetLine()">Antlr4.Runtime.Lexer.GetLine()</see>
+		/// <see cref="Antlr4.Runtime.Lexer.Line()">Antlr4.Runtime.Lexer.Line()</see>
 		/// ,
 		/// and
-		/// <see cref="Antlr4.Runtime.Lexer.GetCharPositionInLine()">Antlr4.Runtime.Lexer.GetCharPositionInLine()
-		/// 	</see>
+		/// <see cref="Antlr4.Runtime.Lexer.Column()">Antlr4.Runtime.Lexer.Column()</see>
 		/// , properly reflect the current
 		/// lexer state. This method should restore
 		/// <code>input</code>
@@ -586,7 +585,7 @@ namespace Antlr4.Runtime.Atn
 			}
 			int savedCharPositionInLine = charPositionInLine;
 			int savedLine = line;
-			int index = input.Index();
+			int index = input.Index;
 			int marker = input.Mark();
 			try
 			{
@@ -605,7 +604,7 @@ namespace Antlr4.Runtime.Atn
 		protected internal virtual void CaptureSimState(LexerATNSimulator.SimState settings
 			, ICharStream input, DFAState dfaState)
 		{
-			settings.index = input.Index();
+			settings.index = input.Index;
 			settings.line = line;
 			settings.charPos = charPositionInLine;
 			settings.dfaState = dfaState;
@@ -690,7 +689,7 @@ namespace Antlr4.Runtime.Atn
 		public virtual string GetText(ICharStream input)
 		{
 			// index is first lookahead char, don't include.
-			return input.GetText(Interval.Of(startIndex, input.Index() - 1));
+			return input.GetText(Interval.Of(startIndex, input.Index - 1));
 		}
 
 		public virtual int GetLine()
diff --git a/Antlr4.Runtime/Atn/NotSetTransition.cs b/Antlr4.Runtime/Atn/NotSetTransition.cs
index 12c9bcda8..41c0b814a 100644
--- a/Antlr4.Runtime/Atn/NotSetTransition.cs
+++ b/Antlr4.Runtime/Atn/NotSetTransition.cs
@@ -39,9 +39,12 @@ namespace Antlr4.Runtime.Atn
 		{
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return NotSet;
+			get
+			{
+				return NotSet;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/ParserATNSimulator.cs b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
index 60d6074fb..13c033df0 100644
--- a/Antlr4.Runtime/Atn/ParserATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
@@ -343,7 +343,7 @@ namespace Antlr4.Runtime.Atn
 				//dump(dfa);
 				// start with the DFA
 				int m = input.Mark();
-				int index = input.Index();
+				int index = input.Index;
 				try
 				{
 					int alt = ExecDFA(dfa, input, index, state);
@@ -371,17 +371,17 @@ namespace Antlr4.Runtime.Atn
 			ParserRuleContext remainingContext = outerContext;
 			System.Diagnostics.Debug.Assert(outerContext != null);
 			DFAState s0 = dfa.s0full.Get();
-			while (remainingContext != null && s0 != null && s0.IsContextSensitive())
+			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());
+					System.Diagnostics.Debug.Assert(s0 == null || !s0.IsContextSensitive);
 				}
 				else
 				{
-					remainingContext = ((ParserRuleContext)remainingContext.GetParent());
+					remainingContext = ((ParserRuleContext)remainingContext.Parent);
 				}
 			}
 			if (s0 == null)
@@ -400,7 +400,7 @@ namespace Antlr4.Runtime.Atn
 			}
 			int alt = 0;
 			int m = input.Mark();
-			int index = input.Index();
+			int index = input.Index;
 			try
 			{
 				SimulatorState state = ComputeStartState(dfa, outerContext, useContext);
@@ -452,7 +452,7 @@ namespace Antlr4.Runtime.Atn
 								, remainingOuterContext);
 							return ExecATN(dfa, input, startIndex, initialState);
 						}
-						remainingOuterContext = ((ParserRuleContext)remainingOuterContext.GetParent());
+						remainingOuterContext = ((ParserRuleContext)remainingOuterContext.Parent);
 						s = next;
 					}
 				}
@@ -523,7 +523,7 @@ namespace Antlr4.Runtime.Atn
 				if (dfa.atnStartState is DecisionState)
 				{
 					if (!userWantsCtxSensitive || !acceptState.configs.GetDipsIntoOuterContext() || (
-						treat_sllk1_conflict_as_ambiguity && input.Index() == startIndex))
+						treat_sllk1_conflict_as_ambiguity && input.Index == startIndex))
 					{
 					}
 					else
@@ -538,7 +538,7 @@ namespace Antlr4.Runtime.Atn
 						// immediate decision
 						if (acceptState.predicates != null)
 						{
-							int conflictIndex = input.Index();
+							int conflictIndex = input.Index;
 							if (conflictIndex != startIndex)
 							{
 								input.Seek(startIndex);
@@ -558,7 +558,7 @@ namespace Antlr4.Runtime.Atn
 						if (reportAmbiguities)
 						{
 							SimulatorState fullContextState = ComputeStartState(dfa, outerContext, true);
-							ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index());
+							ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index);
 						}
 						input.Seek(startIndex);
 						return AdaptivePredict(input, dfa.decision, outerContext, true);
@@ -569,7 +569,7 @@ namespace Antlr4.Runtime.Atn
 			// disambiguating or validating predicates to evaluate
 			if (s.predicates != null)
 			{
-				int stopIndex = input.Index();
+				int stopIndex = input.Index;
 				if (startIndex != stopIndex)
 				{
 					input.Seek(startIndex);
@@ -679,7 +679,7 @@ namespace Antlr4.Runtime.Atn
 						.InvalidAltNumber;
 					if (predictedAlt != ATN.InvalidAltNumber)
 					{
-						if (optimize_ll1 && input.Index() == startIndex && nextState.outerContext == nextState
+						if (optimize_ll1 && input.Index == startIndex && nextState.outerContext == nextState
 							.remainingOuterContext && dfa.decision >= 0 && !D.configs.HasSemanticContext())
 						{
 							if (t >= 0 && t <= short.MaxValue)
@@ -690,7 +690,7 @@ namespace Antlr4.Runtime.Atn
 						}
 						if (useContext && always_try_local_context)
 						{
-							ReportContextSensitivity(dfa, nextState, startIndex, input.Index());
+							ReportContextSensitivity(dfa, nextState, startIndex, input.Index);
 						}
 					}
 					else
@@ -701,12 +701,12 @@ namespace Antlr4.Runtime.Atn
 							//						int k = input.index() - startIndex + 1; // how much input we used
 							//						System.out.println("used k="+k);
 							if (!userWantsCtxSensitive || !D.configs.GetDipsIntoOuterContext() || (treat_sllk1_conflict_as_ambiguity
-								 && input.Index() == startIndex))
+								 && input.Index == startIndex))
 							{
 								if (reportAmbiguities && !D.configs.HasSemanticContext())
 								{
-									ReportAmbiguity(dfa, D, startIndex, input.Index(), D.configs.GetConflictingAlts()
-										, D.configs);
+									ReportAmbiguity(dfa, D, startIndex, input.Index, D.configs.GetConflictingAlts(), 
+										D.configs);
 								}
 							}
 							else
@@ -719,7 +719,7 @@ namespace Antlr4.Runtime.Atn
 									DFAState.PredPrediction[] predPredictions = D.predicates;
 									if (predPredictions != null)
 									{
-										int conflictIndex = input.Index();
+										int conflictIndex = input.Index;
 										if (conflictIndex != startIndex)
 										{
 											input.Seek(startIndex);
@@ -741,7 +741,7 @@ namespace Antlr4.Runtime.Atn
 								SimulatorState fullContextState = ComputeStartState(dfa, outerContext, true);
 								if (reportAmbiguities)
 								{
-									ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index());
+									ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index);
 								}
 								input.Seek(startIndex);
 								return ExecATN(dfa, input, startIndex, fullContextState);
@@ -750,7 +750,7 @@ namespace Antlr4.Runtime.Atn
 					}
 					if (D.predicates != null)
 					{
-						int stopIndex = input.Index();
+						int stopIndex = input.Index;
 						if (startIndex != stopIndex)
 						{
 							input.Seek(startIndex);
@@ -836,7 +836,7 @@ namespace Antlr4.Runtime.Atn
 					{
 						break;
 					}
-					remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.GetParent());
+					remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
 					s = next;
 				}
 			}
@@ -870,7 +870,7 @@ namespace Antlr4.Runtime.Atn
 				{
 					if (c.GetState() is RuleStopState)
 					{
-						System.Diagnostics.Debug.Assert(c.GetContext().IsEmpty());
+						System.Diagnostics.Debug.Assert(c.GetContext().IsEmpty);
 						if (useContext && !c.GetReachesIntoOuterContext() || t == IIntStream.Eof)
 						{
 							if (skippedStopStates == null)
@@ -932,7 +932,7 @@ namespace Antlr4.Runtime.Atn
 					}
 					else
 					{
-						remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.GetParent());
+						remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
 					}
 					contextElements.Add(nextContextElement);
 					if (nextContextElement != PredictionContext.EmptyFullStateKey)
@@ -1034,7 +1034,7 @@ namespace Antlr4.Runtime.Atn
 			PredictionContextCache contextCache = new PredictionContextCache();
 			if (useContext)
 			{
-				while (s0 != null && s0.IsContextSensitive() && remainingGlobalContext != null)
+				while (s0 != null && s0.IsContextSensitive && remainingGlobalContext != null)
 				{
 					DFAState next;
 					remainingGlobalContext = SkipTailCalls(remainingGlobalContext);
@@ -1049,7 +1049,7 @@ namespace Antlr4.Runtime.Atn
 						previousContext = GetReturnState(remainingGlobalContext);
 						next = s0.GetContextTarget(previousContext);
 						initialContext = initialContext.AppendContext(previousContext, contextCache);
-						remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.GetParent());
+						remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
 					}
 					if (next == null)
 					{
@@ -1058,7 +1058,7 @@ namespace Antlr4.Runtime.Atn
 					s0 = next;
 				}
 			}
-			if (s0 != null && !s0.IsContextSensitive())
+			if (s0 != null && !s0.IsContextSensitive)
 			{
 				return new SimulatorState(globalContext, s0, useContext, remainingGlobalContext);
 			}
@@ -1111,7 +1111,7 @@ namespace Antlr4.Runtime.Atn
 				}
 				else
 				{
-					remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.GetParent());
+					remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
 				}
 				if (nextContextElement != PredictionContext.EmptyFullStateKey)
 				{
@@ -1313,10 +1313,10 @@ namespace Antlr4.Runtime.Atn
 			if (config.GetState() is RuleStopState)
 			{
 				// We hit rule end. If we have context info, use it
-				if (!config.GetContext().IsEmpty())
+				if (!config.GetContext().IsEmpty)
 				{
-					bool hasEmpty = config.GetContext().HasEmpty();
-					int nonEmptySize = config.GetContext().Size() - (hasEmpty ? 1 : 0);
+					bool hasEmpty = config.GetContext().HasEmpty;
+					int nonEmptySize = config.GetContext().Size - (hasEmpty ? 1 : 0);
 					for (int i = 0; i < nonEmptySize; i++)
 					{
 						PredictionContext newContext = config.GetContext().GetParent(i);
@@ -1329,7 +1329,7 @@ namespace Antlr4.Runtime.Atn
 						// Make sure we track that we are now out of context.
 						c.SetOuterContextDepth(config.GetOuterContextDepth());
 						System.Diagnostics.Debug.Assert(depth > int.MinValue);
-						if (optimize_closure_busy && c.GetContext().IsEmpty() && !closureBusy.AddItem(c))
+						if (optimize_closure_busy && c.GetContext().IsEmpty && !closureBusy.AddItem(c))
 						{
 							continue;
 						}
@@ -1403,7 +1403,7 @@ namespace Antlr4.Runtime.Atn
 
 							case ATNState.RuleStop:
 							{
-								checkClosure = c.GetContext().IsEmpty();
+								checkClosure = c.GetContext().IsEmpty;
 								break;
 							}
 
@@ -1482,7 +1482,7 @@ namespace Antlr4.Runtime.Atn
 		public virtual ATNConfig GetEpsilonTarget(ATNConfig config, Transition t, bool collectPredicates
 			, bool inContext, PredictionContextCache contextCache)
 		{
-			switch (t.GetSerializationType())
+			switch (t.SerializationType)
 			{
 				case Transition.Rule:
 				{
@@ -2167,14 +2167,14 @@ namespace Antlr4.Runtime.Atn
 			{
 				ATNState state = atn.states[context.invokingState];
 				System.Diagnostics.Debug.Assert(state.GetNumberOfTransitions() == 1 && state.Transition
-					(0).GetSerializationType() == Transition.Rule);
+					(0).SerializationType == Transition.Rule);
 				Antlr4.Runtime.Atn.RuleTransition transition = (Antlr4.Runtime.Atn.RuleTransition
 					)state.Transition(0);
 				if (!transition.tailCall)
 				{
 					break;
 				}
-				context = ((ParserRuleContext)context.GetParent());
+				context = ((ParserRuleContext)context.Parent);
 			}
 			return context;
 		}
diff --git a/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs b/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
index ec5e4c2fc..29489ca05 100644
--- a/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
+++ b/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
@@ -43,14 +43,20 @@ namespace Antlr4.Runtime.Atn
 			this.precedence = precedence;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Precedence;
+			get
+			{
+				return Precedence;
+			}
 		}
 
-		public override bool IsEpsilon()
+		public override bool IsEpsilon
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/PredicateTransition.cs b/Antlr4.Runtime/Atn/PredicateTransition.cs
index 4857c87f1..5356561e2 100644
--- a/Antlr4.Runtime/Atn/PredicateTransition.cs
+++ b/Antlr4.Runtime/Atn/PredicateTransition.cs
@@ -61,14 +61,20 @@ namespace Antlr4.Runtime.Atn
 			this.isCtxDependent = isCtxDependent;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Predicate;
+			get
+			{
+				return Predicate;
+			}
 		}
 
-		public override bool IsEpsilon()
+		public override bool IsEpsilon
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/PredictionContext.cs b/Antlr4.Runtime/Atn/PredictionContext.cs
index c960f0ee7..6cceb93c2 100644
--- a/Antlr4.Runtime/Atn/PredictionContext.cs
+++ b/Antlr4.Runtime/Atn/PredictionContext.cs
@@ -134,7 +134,10 @@ namespace Antlr4.Runtime.Atn
 			return (InitialHash * HashMultiplier ^ parentHashCode) * HashMultiplier ^ returnStateHashCode;
 		}
 
-		public abstract int Size();
+		public abstract int Size
+		{
+			get;
+		}
 
 		public abstract int GetReturnState(int index);
 
@@ -203,19 +206,19 @@ namespace Antlr4.Runtime.Atn
 			{
 				return context0;
 			}
-			if (context0.IsEmpty())
+			if (context0.IsEmpty)
 			{
 				return IsEmptyLocal(context0) ? context0 : AddEmptyContext(context1);
 			}
 			else
 			{
-				if (context1.IsEmpty())
+				if (context1.IsEmpty)
 				{
 					return IsEmptyLocal(context1) ? context1 : AddEmptyContext(context0);
 				}
 			}
-			int context0size = context0.Size();
-			int context1size = context1.Size();
+			int context0size = context0.Size;
+			int context1size = context1.Size;
 			if (context0size == 1 && context1size == 1 && context0.GetReturnState(0) == context1
 				.GetReturnState(0))
 			{
@@ -339,7 +342,7 @@ namespace Antlr4.Runtime.Atn
 			 context, IConcurrentMap<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext
 			> contextCache, PredictionContext.IdentityHashMap visited)
 		{
-			if (context.IsEmpty())
+			if (context.IsEmpty)
 			{
 				return context;
 			}
@@ -356,7 +359,7 @@ namespace Antlr4.Runtime.Atn
 			}
 			bool changed = false;
 			Antlr4.Runtime.Atn.PredictionContext[] parents = new Antlr4.Runtime.Atn.PredictionContext
-				[context.Size()];
+				[context.Size];
 			for (int i = 0; i < parents.Length; i++)
 			{
 				Antlr4.Runtime.Atn.PredictionContext parent = GetCachedContext(context.GetParent(
@@ -365,8 +368,8 @@ namespace Antlr4.Runtime.Atn
 				{
 					if (!changed)
 					{
-						parents = new Antlr4.Runtime.Atn.PredictionContext[context.Size()];
-						for (int j = 0; j < context.Size(); j++)
+						parents = new Antlr4.Runtime.Atn.PredictionContext[context.Size];
+						for (int j = 0; j < context.Size; j++)
 						{
 							parents[j] = context.GetParent(j);
 						}
@@ -414,9 +417,15 @@ namespace Antlr4.Runtime.Atn
 			return new SingletonPredictionContext(this, returnState);
 		}
 
-		public abstract bool IsEmpty();
+		public abstract bool IsEmpty
+		{
+			get;
+		}
 
-		public abstract bool HasEmpty();
+		public abstract bool HasEmpty
+		{
+			get;
+		}
 
 		public sealed override int GetHashCode()
 		{
@@ -448,20 +457,20 @@ namespace Antlr4.Runtime.Atn
 				int stateNumber = currentState;
 				StringBuilder localBuffer = new StringBuilder();
 				localBuffer.Append("[");
-				while (!p.IsEmpty() && p != stop)
+				while (!p.IsEmpty && p != stop)
 				{
 					int index = 0;
-					if (p.Size() > 0)
+					if (p.Size > 0)
 					{
 						int bits = 1;
-						while ((1 << bits) < p.Size())
+						while ((1 << bits) < p.Size)
 						{
 							bits++;
 						}
 						int mask = (1 << bits) - 1;
 						index = (perm >> offset) & mask;
-						last &= index >= p.Size() - 1;
-						if (index >= p.Size())
+						last &= index >= p.Size - 1;
+						if (index >= p.Size)
 						{
 							goto outer_continue;
 						}
@@ -483,7 +492,7 @@ namespace Antlr4.Runtime.Atn
 					{
 						if (p.GetReturnState(index) != EmptyFullStateKey)
 						{
-							if (!p.IsEmpty())
+							if (!p.IsEmpty)
 							{
 								if (localBuffer.Length > 1)
 								{
diff --git a/Antlr4.Runtime/Atn/PredictionContextCache.cs b/Antlr4.Runtime/Atn/PredictionContextCache.cs
index 90c93b3df..431a6491d 100644
--- a/Antlr4.Runtime/Atn/PredictionContextCache.cs
+++ b/Antlr4.Runtime/Atn/PredictionContextCache.cs
@@ -174,14 +174,20 @@ namespace Antlr4.Runtime.Atn
 				this.y = y;
 			}
 
-			public PredictionContext GetX()
+			public PredictionContext X
 			{
-				return x;
+				get
+				{
+					return x;
+				}
 			}
 
-			public PredictionContext GetY()
+			public PredictionContext Y
 			{
-				return y;
+				get
+				{
+					return y;
+				}
 			}
 
 			public override bool Equals(object obj)
diff --git a/Antlr4.Runtime/Atn/RangeTransition.cs b/Antlr4.Runtime/Atn/RangeTransition.cs
index 05fb2d46c..6f22f5d28 100644
--- a/Antlr4.Runtime/Atn/RangeTransition.cs
+++ b/Antlr4.Runtime/Atn/RangeTransition.cs
@@ -45,15 +45,20 @@ namespace Antlr4.Runtime.Atn
 			this.to = to;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Range;
+			get
+			{
+				return Range;
+			}
 		}
 
-		[NotNull]
-		public override IntervalSet Label()
+		public override IntervalSet Label
 		{
-			return IntervalSet.Of(from, to);
+			get
+			{
+				return IntervalSet.Of(from, to);
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/RuleTransition.cs b/Antlr4.Runtime/Atn/RuleTransition.cs
index a1eb5a4ed..66be47b37 100644
--- a/Antlr4.Runtime/Atn/RuleTransition.cs
+++ b/Antlr4.Runtime/Atn/RuleTransition.cs
@@ -57,14 +57,20 @@ namespace Antlr4.Runtime.Atn
 			this.followState = followState;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Rule;
+			get
+			{
+				return Rule;
+			}
 		}
 
-		public override bool IsEpsilon()
+		public override bool IsEpsilon
 		{
-			return true;
+			get
+			{
+				return true;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/SetTransition.cs b/Antlr4.Runtime/Atn/SetTransition.cs
index fa8513a9c..b0474b44f 100644
--- a/Antlr4.Runtime/Atn/SetTransition.cs
+++ b/Antlr4.Runtime/Atn/SetTransition.cs
@@ -51,15 +51,20 @@ namespace Antlr4.Runtime.Atn
 			this.set = set;
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Set;
+			get
+			{
+				return Set;
+			}
 		}
 
-		[NotNull]
-		public override IntervalSet Label()
+		public override IntervalSet Label
 		{
-			return set;
+			get
+			{
+				return set;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/Atn/SingletonPredictionContext.cs b/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
index 005ac3635..6dff57647 100644
--- a/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
@@ -67,19 +67,28 @@ namespace Antlr4.Runtime.Atn
 			return this.returnState == returnState ? 0 : -1;
 		}
 
-		public override int Size()
+		public override int Size
 		{
-			return 1;
+			get
+			{
+				return 1;
+			}
 		}
 
-		public override bool IsEmpty()
+		public override bool IsEmpty
 		{
-			return false;
+			get
+			{
+				return false;
+			}
 		}
 
-		public override bool HasEmpty()
+		public override bool HasEmpty
 		{
-			return false;
+			get
+			{
+				return false;
+			}
 		}
 
 		public override PredictionContext AppendContext(PredictionContext suffix, PredictionContextCache
diff --git a/Antlr4.Runtime/Atn/Transition.cs b/Antlr4.Runtime/Atn/Transition.cs
index 84f2da870..49fefb0dc 100644
--- a/Antlr4.Runtime/Atn/Transition.cs
+++ b/Antlr4.Runtime/Atn/Transition.cs
@@ -115,18 +115,26 @@ namespace Antlr4.Runtime.Atn
 			this.target = target;
 		}
 
-		public abstract int GetSerializationType();
-
-		/// <summary>Are we epsilon, action, sempred?</summary>
-		public virtual bool IsEpsilon()
+		public abstract int SerializationType
 		{
-			return false;
+			get;
 		}
 
-		[Nullable]
-		public virtual IntervalSet Label()
+		/// <summary>Are we epsilon, action, sempred?</summary>
+		public virtual bool IsEpsilon
 		{
-			return null;
+			get
+			{
+				return false;
+			}
+		}
+
+		public virtual IntervalSet Label
+		{
+			get
+			{
+				return null;
+			}
 		}
 
 		public abstract bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol);
diff --git a/Antlr4.Runtime/Atn/WildcardTransition.cs b/Antlr4.Runtime/Atn/WildcardTransition.cs
index 34247c8d6..8438a9a69 100644
--- a/Antlr4.Runtime/Atn/WildcardTransition.cs
+++ b/Antlr4.Runtime/Atn/WildcardTransition.cs
@@ -39,9 +39,12 @@ namespace Antlr4.Runtime.Atn
 		{
 		}
 
-		public override int GetSerializationType()
+		public override int SerializationType
 		{
-			return Wildcard;
+			get
+			{
+				return Wildcard;
+			}
 		}
 
 		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
diff --git a/Antlr4.Runtime/BailErrorStrategy.cs b/Antlr4.Runtime/BailErrorStrategy.cs
index 3e29e46bd..1d7cfc7cc 100644
--- a/Antlr4.Runtime/BailErrorStrategy.cs
+++ b/Antlr4.Runtime/BailErrorStrategy.cs
@@ -57,7 +57,7 @@ namespace Antlr4.Runtime
 		public override void Recover(Parser recognizer, RecognitionException e)
 		{
 			for (ParserRuleContext context = recognizer.GetContext(); context != null; context
-				 = ((ParserRuleContext)context.GetParent()))
+				 = ((ParserRuleContext)context.Parent))
 			{
 				context.exception = e;
 			}
@@ -77,7 +77,7 @@ namespace Antlr4.Runtime
 		{
 			InputMismatchException e = new InputMismatchException(recognizer);
 			for (ParserRuleContext context = recognizer.GetContext(); context != null; context
-				 = ((ParserRuleContext)context.GetParent()))
+				 = ((ParserRuleContext)context.Parent))
 			{
 				context.exception = e;
 			}
diff --git a/Antlr4.Runtime/BufferedTokenStream.cs b/Antlr4.Runtime/BufferedTokenStream.cs
index fa3183145..61d1edfc4 100644
--- a/Antlr4.Runtime/BufferedTokenStream.cs
+++ b/Antlr4.Runtime/BufferedTokenStream.cs
@@ -122,14 +122,20 @@ namespace Antlr4.Runtime
 			this.tokenSource = tokenSource;
 		}
 
-		public virtual ITokenSource GetTokenSource()
+		public virtual ITokenSource TokenSource
 		{
-			return tokenSource;
+			get
+			{
+				return tokenSource;
+			}
 		}
 
-		public virtual int Index()
+		public virtual int Index
 		{
-			return p;
+			get
+			{
+				return p;
+			}
 		}
 
 		//	public int range() { return range; }
@@ -154,9 +160,12 @@ namespace Antlr4.Runtime
 			p = AdjustSeekIndex(index);
 		}
 
-		public virtual int Size()
+		public virtual int Size
 		{
-			return tokens.Count;
+			get
+			{
+				return tokens.Count;
+			}
 		}
 
 		public virtual void Consume()
@@ -217,10 +226,10 @@ namespace Antlr4.Runtime
 				IToken t = tokenSource.NextToken();
 				if (t is IWritableToken)
 				{
-					((IWritableToken)t).SetTokenIndex(tokens.Count);
+					((IWritableToken)t).TokenIndex = tokens.Count;
 				}
 				tokens.AddItem(t);
-				if (t.GetType() == IToken.Eof)
+				if (t.Type == IToken.Eof)
 				{
 					fetchedEOF = true;
 					return i + 1;
@@ -256,7 +265,7 @@ namespace Antlr4.Runtime
 			for (int i = start; i <= stop; i++)
 			{
 				IToken t = tokens[i];
-				if (t.GetType() == IToken.Eof)
+				if (t.Type == IToken.Eof)
 				{
 					break;
 				}
@@ -267,7 +276,7 @@ namespace Antlr4.Runtime
 
 		public virtual int La(int i)
 		{
-			return Lt(i).GetType();
+			return Lt(i).Type;
 		}
 
 		protected internal virtual IToken Lb(int k)
@@ -389,7 +398,7 @@ namespace Antlr4.Runtime
 			for (int i = start; i <= stop; i++)
 			{
 				IToken t = tokens[i];
-				if (types == null || types.Get(t.GetType()))
+				if (types == null || types.Get(t.Type))
 				{
 					filteredTokens.AddItem(t);
 				}
@@ -426,13 +435,13 @@ namespace Antlr4.Runtime
 		{
 			Sync(i);
 			IToken token = tokens[i];
-			if (i >= Size())
+			if (i >= Size)
 			{
 				return -1;
 			}
-			while (token.GetChannel() != channel)
+			while (token.Channel != channel)
 			{
-				if (token.GetType() == IToken.Eof)
+				if (token.Type == IToken.Eof)
 				{
 					return -1;
 				}
@@ -462,7 +471,7 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		protected internal virtual int PreviousTokenOnChannel(int i, int channel)
 		{
-			while (i >= 0 && tokens[i].GetChannel() != channel)
+			while (i >= 0 && tokens[i].Channel != channel)
 			{
 				i--;
 			}
@@ -494,7 +503,7 @@ namespace Antlr4.Runtime
 			// if none onchannel to right, nextOnChannel=-1 so set to = last token
 			if (nextOnChannel == -1)
 			{
-				to = Size() - 1;
+				to = Size - 1;
 			}
 			else
 			{
@@ -565,14 +574,14 @@ namespace Antlr4.Runtime
 				IToken t = tokens[i];
 				if (channel == -1)
 				{
-					if (t.GetChannel() != Lexer.DefaultTokenChannel)
+					if (t.Channel != Lexer.DefaultTokenChannel)
 					{
 						hidden.AddItem(t);
 					}
 				}
 				else
 				{
-					if (t.GetChannel() == channel)
+					if (t.Channel == channel)
 					{
 						hidden.AddItem(t);
 					}
@@ -585,9 +594,12 @@ namespace Antlr4.Runtime
 			return hidden;
 		}
 
-		public virtual string GetSourceName()
+		public virtual string SourceName
 		{
-			return tokenSource.GetSourceName();
+			get
+			{
+				return tokenSource.SourceName;
+			}
 		}
 
 		/// <summary>Get the text of all tokens in this buffer.</summary>
@@ -596,7 +608,7 @@ namespace Antlr4.Runtime
 		public virtual string GetText()
 		{
 			Fill();
-			return GetText(Interval.Of(0, Size() - 1));
+			return GetText(Interval.Of(0, Size - 1));
 		}
 
 		[NotNull]
@@ -617,11 +629,11 @@ namespace Antlr4.Runtime
 			for (int i = start; i <= stop; i++)
 			{
 				IToken t = tokens[i];
-				if (t.GetType() == IToken.Eof)
+				if (t.Type == IToken.Eof)
 				{
 					break;
 				}
-				buf.Append(t.GetText());
+				buf.Append(t.Text);
 			}
 			return buf.ToString();
 		}
@@ -629,7 +641,7 @@ namespace Antlr4.Runtime
 		[NotNull]
 		public virtual string GetText(RuleContext ctx)
 		{
-			return GetText(ctx.GetSourceInterval());
+			return GetText(ctx.SourceInterval);
 		}
 
 		[NotNull]
@@ -637,7 +649,7 @@ namespace Antlr4.Runtime
 		{
 			if (start != null && stop != null)
 			{
-				return GetText(Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex()));
+				return GetText(Interval.Of(start.TokenIndex, stop.TokenIndex));
 			}
 			return string.Empty;
 		}
diff --git a/Antlr4.Runtime/CommonToken.cs b/Antlr4.Runtime/CommonToken.cs
index 51689d184..b1802042e 100644
--- a/Antlr4.Runtime/CommonToken.cs
+++ b/Antlr4.Runtime/CommonToken.cs
@@ -84,8 +84,8 @@ namespace Antlr4.Runtime
 			this.stop = stop;
 			if (source.GetItem1() != null)
 			{
-				this.line = source.GetItem1().GetLine();
-				this.charPositionInLine = source.GetItem1().GetCharPositionInLine();
+				this.line = source.GetItem1().Line;
+				this.charPositionInLine = source.GetItem1().Column;
 			}
 		}
 
@@ -98,53 +98,47 @@ namespace Antlr4.Runtime
 
 		public CommonToken(IToken oldToken)
 		{
-			text = oldToken.GetText();
-			type = oldToken.GetType();
-			line = oldToken.GetLine();
-			index = oldToken.GetTokenIndex();
-			charPositionInLine = oldToken.GetCharPositionInLine();
-			channel = oldToken.GetChannel();
-			start = oldToken.GetStartIndex();
-			stop = oldToken.GetStopIndex();
+			text = oldToken.Text;
+			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)
 			{
 				source = ((Antlr4.Runtime.CommonToken)oldToken).source;
 			}
 			else
 			{
-				source = Tuple.Create(oldToken.GetTokenSource(), oldToken.GetInputStream());
+				source = Tuple.Create(oldToken.TokenSource, oldToken.InputStream);
 			}
 		}
 
-		public virtual int GetType()
+		public virtual int Type
 		{
-			return type;
+			get
+			{
+				return type;
+			}
+			set
+			{
+				int type = value;
+				this.type = type;
+			}
 		}
 
-		public virtual void SetLine(int line)
+		public virtual int Line
 		{
-			this.line = line;
-		}
-
-		public virtual string GetText()
-		{
-			if (text != null)
+			get
 			{
-				return text;
+				return line;
 			}
-			ICharStream input = GetInputStream();
-			if (input == null)
+			set
 			{
-				return null;
-			}
-			int n = input.Size();
-			if (start < n && stop < n)
-			{
-				return input.GetText(Interval.Of(start, stop));
-			}
-			else
-			{
-				return "<EOF>";
+				int line = value;
+				this.line = line;
 			}
 		}
 
@@ -155,44 +149,68 @@ namespace Antlr4.Runtime
 		/// that start/stop indexes are not valid.  It means that that input
 		/// was converted to a new string in the token object.
 		/// </remarks>
-		public virtual void SetText(string text)
+		public virtual string Text
 		{
-			this.text = 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
+			{
+				string text = value;
+				this.text = text;
+			}
 		}
 
-		public virtual int GetLine()
+		public virtual int Column
 		{
-			return line;
+			get
+			{
+				return charPositionInLine;
+			}
+			set
+			{
+				int charPositionInLine = value;
+				this.charPositionInLine = charPositionInLine;
+			}
 		}
 
-		public virtual int GetCharPositionInLine()
+		public virtual int Channel
 		{
-			return charPositionInLine;
+			get
+			{
+				return channel;
+			}
+			set
+			{
+				int channel = value;
+				this.channel = channel;
+			}
 		}
 
-		public virtual void SetCharPositionInLine(int charPositionInLine)
+		public virtual int StartIndex
 		{
-			this.charPositionInLine = charPositionInLine;
-		}
-
-		public virtual int GetChannel()
-		{
-			return channel;
-		}
-
-		public virtual void SetChannel(int channel)
-		{
-			this.channel = channel;
-		}
-
-		public virtual void SetType(int type)
-		{
-			this.type = type;
-		}
-
-		public virtual int GetStartIndex()
-		{
-			return start;
+			get
+			{
+				return start;
+			}
 		}
 
 		public virtual void SetStartIndex(int start)
@@ -200,9 +218,12 @@ namespace Antlr4.Runtime
 			this.start = start;
 		}
 
-		public virtual int GetStopIndex()
+		public virtual int StopIndex
 		{
-			return stop;
+			get
+			{
+				return stop;
+			}
 		}
 
 		public virtual void SetStopIndex(int stop)
@@ -210,24 +231,33 @@ namespace Antlr4.Runtime
 			this.stop = stop;
 		}
 
-		public virtual int GetTokenIndex()
+		public virtual int TokenIndex
 		{
-			return index;
+			get
+			{
+				return index;
+			}
+			set
+			{
+				int index = value;
+				this.index = index;
+			}
 		}
 
-		public virtual void SetTokenIndex(int index)
+		public virtual ITokenSource TokenSource
 		{
-			this.index = index;
+			get
+			{
+				return source.GetItem1();
+			}
 		}
 
-		public virtual ITokenSource GetTokenSource()
+		public virtual ICharStream InputStream
 		{
-			return source.GetItem1();
-		}
-
-		public virtual ICharStream GetInputStream()
-		{
-			return source.GetItem2();
+			get
+			{
+				return source.GetItem2();
+			}
 		}
 
 		public override string ToString()
@@ -237,7 +267,7 @@ namespace Antlr4.Runtime
 			{
 				channelStr = ",channel=" + channel;
 			}
-			string txt = GetText();
+			string txt = Text;
 			if (txt != null)
 			{
 				txt = txt.ReplaceAll("\n", "\\\\n");
@@ -248,8 +278,8 @@ namespace Antlr4.Runtime
 			{
 				txt = "<no text>";
 			}
-			return "[@" + GetTokenIndex() + "," + start + ":" + stop + "='" + txt + "',<" + type
-				 + ">" + channelStr + "," + line + ":" + GetCharPositionInLine() + "]";
+			return "[@" + TokenIndex + "," + start + ":" + stop + "='" + txt + "',<" + type +
+				 ">" + channelStr + "," + line + ":" + Column + "]";
 		}
 	}
 }
diff --git a/Antlr4.Runtime/CommonTokenFactory.cs b/Antlr4.Runtime/CommonTokenFactory.cs
index 84f5f3449..423c89602 100644
--- a/Antlr4.Runtime/CommonTokenFactory.cs
+++ b/Antlr4.Runtime/CommonTokenFactory.cs
@@ -68,17 +68,17 @@ namespace Antlr4.Runtime
 			int channel, int start, int stop, int line, int charPositionInLine) where _T0:ITokenSource
 		{
 			CommonToken t = new CommonToken(source, type, channel, start, stop);
-			t.SetLine(line);
-			t.SetCharPositionInLine(charPositionInLine);
+			t.Line = line;
+			t.Column = charPositionInLine;
 			if (text != null)
 			{
-				t.SetText(text);
+				t.Text = text;
 			}
 			else
 			{
 				if (copyText && source.GetItem2() != null)
 				{
-					t.SetText(source.GetItem2().GetText(Interval.Of(start, stop)));
+					t.Text = source.GetItem2().GetText(Interval.Of(start, stop));
 				}
 			}
 			return t;
diff --git a/Antlr4.Runtime/CommonTokenStream.cs b/Antlr4.Runtime/CommonTokenStream.cs
index 17e7a3151..bd26f3a9e 100644
--- a/Antlr4.Runtime/CommonTokenStream.cs
+++ b/Antlr4.Runtime/CommonTokenStream.cs
@@ -141,11 +141,11 @@ namespace Antlr4.Runtime
 			for (int i = 0; i < tokens.Count; i++)
 			{
 				IToken t = tokens[i];
-				if (t.GetChannel() == channel)
+				if (t.Channel == channel)
 				{
 					n++;
 				}
-				if (t.GetType() == IToken.Eof)
+				if (t.Type == IToken.Eof)
 				{
 					break;
 				}
diff --git a/Antlr4.Runtime/DefaultErrorStrategy.cs b/Antlr4.Runtime/DefaultErrorStrategy.cs
index 5414b2cd5..a4d51371b 100644
--- a/Antlr4.Runtime/DefaultErrorStrategy.cs
+++ b/Antlr4.Runtime/DefaultErrorStrategy.cs
@@ -145,7 +145,7 @@ namespace Antlr4.Runtime
 			//						   ", lastErrorIndex="+
 			//						   lastErrorIndex+
 			//						   ", states="+lastErrorStates);
-			if (lastErrorIndex == ((ITokenStream)recognizer.GetInputStream()).Index() && lastErrorStates
+			if (lastErrorIndex == ((ITokenStream)recognizer.GetInputStream()).Index && lastErrorStates
 				 != null && lastErrorStates.Contains(recognizer.GetState()))
 			{
 				// uh oh, another error at same token index and previously-visited
@@ -157,7 +157,7 @@ namespace Antlr4.Runtime
 				//			System.err.println("FAILSAFE consumes "+recognizer.getTokenNames()[recognizer.getInputStream().LA(1)]);
 				recognizer.Consume();
 			}
-			lastErrorIndex = ((ITokenStream)recognizer.GetInputStream()).Index();
+			lastErrorIndex = ((ITokenStream)recognizer.GetInputStream()).Index;
 			if (lastErrorStates == null)
 			{
 				lastErrorStates = new IntervalSet();
@@ -249,7 +249,7 @@ namespace Antlr4.Runtime
 			string input;
 			if (tokens != null)
 			{
-				if (e.GetStartToken().GetType() == IToken.Eof)
+				if (e.GetStartToken().Type == IToken.Eof)
 				{
 					input = "<EOF>";
 				}
@@ -437,21 +437,21 @@ namespace Antlr4.Runtime
 			}
 			IToken current = currentSymbol;
 			IToken lookback = ((ITokenStream)recognizer.GetInputStream()).Lt(-1);
-			if (current.GetType() == IToken.Eof && lookback != null)
+			if (current.Type == IToken.Eof && lookback != null)
 			{
 				current = lookback;
 			}
-			return ConstructToken(((ITokenStream)recognizer.GetInputStream()).GetTokenSource(
-				), expectedTokenType, tokenText, current);
+			return ConstructToken(((ITokenStream)recognizer.GetInputStream()).TokenSource, expectedTokenType
+				, tokenText, current);
 		}
 
 		protected internal virtual IToken ConstructToken(ITokenSource tokenSource, int expectedTokenType
 			, string tokenText, IToken current)
 		{
-			ITokenFactory factory = tokenSource.GetTokenFactory();
-			return factory.Create(Tuple.Create(tokenSource, current.GetTokenSource().GetInputStream
-				()), expectedTokenType, tokenText, IToken.DefaultChannel, -1, -1, current.GetLine
-				(), current.GetCharPositionInLine());
+			ITokenFactory factory = tokenSource.TokenFactory;
+			return factory.Create(Tuple.Create(tokenSource, current.TokenSource.InputStream), 
+				expectedTokenType, tokenText, IToken.DefaultChannel, -1, -1, current.Line, current
+				.Column);
 		}
 
 		public virtual IntervalSet GetExpectedTokens(Parser recognizer)
@@ -496,12 +496,12 @@ namespace Antlr4.Runtime
 
 		protected internal virtual string GetSymbolText(IToken symbol)
 		{
-			return symbol.GetText();
+			return symbol.Text;
 		}
 
 		protected internal virtual int GetSymbolType(IToken symbol)
 		{
-			return symbol.GetType();
+			return symbol.Type;
 		}
 
 		protected internal virtual string EscapeWSAndQuote(string s)
diff --git a/Antlr4.Runtime/Dfa/DFASerializer.cs b/Antlr4.Runtime/Dfa/DFASerializer.cs
index 6324f1d86..cb0b8b4b6 100644
--- a/Antlr4.Runtime/Dfa/DFASerializer.cs
+++ b/Antlr4.Runtime/Dfa/DFASerializer.cs
@@ -85,8 +85,8 @@ namespace Antlr4.Runtime.Dfa
 				states.Sort(new _IComparer_85());
 				foreach (DFAState s in states)
 				{
-					IDictionary<int, DFAState> edges = s.GetEdgeMap();
-					IDictionary<int, DFAState> contextEdges = s.GetContextEdgeMap();
+					IDictionary<int, DFAState> edges = s.EdgeMap;
+					IDictionary<int, DFAState> contextEdges = s.ContextEdgeMap;
 					foreach (KeyValuePair<int, DFAState> entry in edges.EntrySet())
 					{
 						if ((entry.Value == null || entry.Value == ATNSimulator.Error) && !s.IsContextSymbol
@@ -115,7 +115,7 @@ namespace Antlr4.Runtime.Dfa
 							}
 						}
 					}
-					if (s.IsContextSensitive())
+					if (s.IsContextSensitive)
 					{
 						foreach (KeyValuePair<int, DFAState> entry_1 in contextEdges.EntrySet())
 						{
@@ -204,7 +204,7 @@ namespace Antlr4.Runtime.Dfa
 					stateStr = ":s" + n + "=>" + s.prediction;
 				}
 			}
-			if (s.IsContextSensitive())
+			if (s.IsContextSensitive)
 			{
 				stateStr += "*";
 				foreach (ATNConfig config in s.configs)
diff --git a/Antlr4.Runtime/Dfa/DFAState.cs b/Antlr4.Runtime/Dfa/DFAState.cs
index ca8d5a824..7aee76338 100644
--- a/Antlr4.Runtime/Dfa/DFAState.cs
+++ b/Antlr4.Runtime/Dfa/DFAState.cs
@@ -154,14 +154,17 @@ namespace Antlr4.Runtime.Dfa
 			this.maxSymbol = maxSymbol;
 		}
 
-		public bool IsContextSensitive()
+		public bool IsContextSensitive
 		{
-			return contextEdges != null;
+			get
+			{
+				return contextEdges != null;
+			}
 		}
 
 		public bool IsContextSymbol(int symbol)
 		{
-			if (!IsContextSensitive() || symbol < minSymbol)
+			if (!IsContextSensitive || symbol < minSymbol)
 			{
 				return false;
 			}
@@ -170,7 +173,7 @@ namespace Antlr4.Runtime.Dfa
 
 		public void SetContextSymbol(int symbol)
 		{
-			System.Diagnostics.Debug.Assert(IsContextSensitive());
+			System.Diagnostics.Debug.Assert(IsContextSensitive);
 			if (symbol < minSymbol)
 			{
 				return;
@@ -183,7 +186,7 @@ namespace Antlr4.Runtime.Dfa
 			lock (this)
 			{
 				System.Diagnostics.Debug.Assert(!configs.IsOutermostConfigSet());
-				if (IsContextSensitive())
+				if (IsContextSensitive)
 				{
 					return;
 				}
@@ -213,13 +216,16 @@ namespace Antlr4.Runtime.Dfa
 			}
 		}
 
-		public virtual IDictionary<int, DFAState> GetEdgeMap()
+		public virtual IDictionary<int, DFAState> EdgeMap
 		{
-			if (edges == null)
+			get
 			{
-				return Sharpen.Collections.EmptyMap();
+				if (edges == null)
+				{
+					return Sharpen.Collections.EmptyMap();
+				}
+				return edges.ToMap();
 			}
-			return edges.ToMap();
 		}
 
 		public virtual DFAState GetContextTarget(int invokingState)
@@ -251,35 +257,38 @@ namespace Antlr4.Runtime.Dfa
 			}
 		}
 
-		public virtual IDictionary<int, DFAState> GetContextEdgeMap()
+		public virtual IDictionary<int, DFAState> ContextEdgeMap
 		{
-			if (contextEdges == null)
+			get
 			{
-				return Sharpen.Collections.EmptyMap();
-			}
-			IDictionary<int, DFAState> map = contextEdges.ToMap();
-			if (map.ContainsKey(-1))
-			{
-				if (map.Count == 1)
+				if (contextEdges == null)
 				{
-					return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.
-						Get(-1));
+					return Sharpen.Collections.EmptyMap();
 				}
-				else
+				IDictionary<int, DFAState> map = contextEdges.ToMap();
+				if (map.ContainsKey(-1))
 				{
-					try
+					if (map.Count == 1)
 					{
-						map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+						return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.
+							Get(-1));
 					}
-					catch (NotSupportedException)
+					else
 					{
-						// handles read only, non-singleton maps
-						map = new LinkedHashMap<int, DFAState>(map);
-						map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+						try
+						{
+							map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+						}
+						catch (NotSupportedException)
+						{
+							// handles read only, non-singleton maps
+							map = new LinkedHashMap<int, DFAState>(map);
+							map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+						}
 					}
 				}
+				return map;
 			}
-			return map;
 		}
 
 		public override int GetHashCode()
diff --git a/Antlr4.Runtime/IIntStream.cs b/Antlr4.Runtime/IIntStream.cs
index c270304a7..a288192bc 100644
--- a/Antlr4.Runtime/IIntStream.cs
+++ b/Antlr4.Runtime/IIntStream.cs
@@ -28,7 +28,6 @@
  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 using Antlr4.Runtime;
-using Antlr4.Runtime.Misc;
 using Sharpen;
 
 namespace Antlr4.Runtime
@@ -69,7 +68,7 @@ namespace Antlr4.Runtime
 
 		/// <summary>
 		/// The value returned by
-		/// <see cref="GetSourceName()">GetSourceName()</see>
+		/// <see cref="SourceName()">SourceName()</see>
 		/// when the actual name of the
 		/// underlying source is not known.
 		/// </summary>
@@ -282,7 +281,10 @@ namespace Antlr4.Runtime
 		/// has occurred after this stream was
 		/// constructed.
 		/// </summary>
-		public abstract int Index();
+		internal abstract int Index
+		{
+			get;
+		}
 
 		/// <summary>
 		/// Set the input cursor to the position indicated by
@@ -346,7 +348,10 @@ namespace Antlr4.Runtime
 		/// if the size of the stream is
 		/// unknown.
 		/// </exception>
-		public abstract int Size();
+		internal abstract int Size
+		{
+			get;
+		}
 
 		/// <summary>Gets the name of the underlying symbol source.</summary>
 		/// <remarks>
@@ -356,7 +361,9 @@ namespace Antlr4.Runtime
 		/// <see cref="UnknownSourceName">UnknownSourceName</see>
 		/// .
 		/// </remarks>
-		[NotNull]
-		public abstract string GetSourceName();
+		public abstract string SourceName
+		{
+			get;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/IToken.cs b/Antlr4.Runtime/IToken.cs
index 7e730fc74..58883fc53 100644
--- a/Antlr4.Runtime/IToken.cs
+++ b/Antlr4.Runtime/IToken.cs
@@ -81,23 +81,37 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		public const int HiddenChannel = 1;
 
-		/// <summary>Get the text of the token</summary>
-		public abstract string GetText();
+		/// <summary>Get the text of the token.</summary>
+		/// <remarks>Get the text of the token.</remarks>
+		internal abstract string Text
+		{
+			get;
+		}
 
-		/// <summary>Get the token type of the token</summary>
-		public abstract int GetType();
+		/// <summary>Get the token type of the token.</summary>
+		/// <remarks>Get the token type of the token.</remarks>
+		internal abstract int Type
+		{
+			get;
+		}
 
 		/// <summary>
 		/// The line number on which the 1st character of this token was matched,
 		/// line=1..n
 		/// </summary>
-		public abstract int GetLine();
+		internal abstract 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>
-		public abstract int GetCharPositionInLine();
+		internal abstract int Column
+		{
+			get;
+		}
 
 		/// <summary>Return the channel this token.</summary>
 		/// <remarks>
@@ -105,7 +119,10 @@ namespace Antlr4.Runtime
 		/// on a different channel, but the parser only "tunes" to a single channel.
 		/// The parser ignores everything not on DEFAULT_CHANNEL.
 		/// </remarks>
-		public abstract int GetChannel();
+		internal abstract int Channel
+		{
+			get;
+		}
 
 		/// <summary>An index from 0..n-1 of the token object in the input stream.</summary>
 		/// <remarks>
@@ -115,7 +132,10 @@ namespace Antlr4.Runtime
 		/// Return -1 to indicate that this token was conjured up since
 		/// it doesn't have a valid index.
 		/// </remarks>
-		public abstract int GetTokenIndex();
+		internal abstract int TokenIndex
+		{
+			get;
+		}
 
 		/// <summary>
 		/// The starting character index of the token
@@ -125,27 +145,39 @@ namespace Antlr4.Runtime
 		/// The starting character index of the token
 		/// This method is optional; return -1 if not implemented.
 		/// </remarks>
-		public abstract int GetStartIndex();
+		internal abstract 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>
-		public abstract int GetStopIndex();
+		internal abstract int StopIndex
+		{
+			get;
+		}
 
 		/// <summary>
 		/// Gets the
 		/// <see cref="ITokenSource">ITokenSource</see>
 		/// which created this token.
 		/// </summary>
-		public abstract ITokenSource GetTokenSource();
+		internal abstract ITokenSource TokenSource
+		{
+			get;
+		}
 
 		/// <summary>
 		/// Gets the
 		/// <see cref="ICharStream">ICharStream</see>
 		/// from which this token was derived.
 		/// </summary>
-		public abstract ICharStream GetInputStream();
+		internal abstract ICharStream InputStream
+		{
+			get;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/ITokenSource.cs b/Antlr4.Runtime/ITokenSource.cs
index aaf50bf07..5dd4e45a1 100644
--- a/Antlr4.Runtime/ITokenSource.cs
+++ b/Antlr4.Runtime/ITokenSource.cs
@@ -60,9 +60,15 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		IToken NextToken();
 
-		int GetLine();
+		int Line
+		{
+			get;
+		}
 
-		int GetCharPositionInLine();
+		int Column
+		{
+			get;
+		}
 
 		/// <summary>
 		/// From what character stream was this token created?  You don't have to
@@ -74,7 +80,10 @@ namespace Antlr4.Runtime
 		/// implement but it's nice to know where a Token comes from if you have
 		/// include files etc... on the input.
 		/// </remarks>
-		ICharStream GetInputStream();
+		ICharStream InputStream
+		{
+			get;
+		}
 
 		/// <summary>
 		/// Where are you getting tokens from? normally the implication will simply
@@ -84,13 +93,18 @@ namespace Antlr4.Runtime
 		/// Where are you getting tokens from? normally the implication will simply
 		/// ask lexers input stream.
 		/// </remarks>
-		string GetSourceName();
+		string SourceName
+		{
+			get;
+		}
 
 		/// <summary>Gets the factory used for constructing tokens.</summary>
 		/// <remarks>Gets the factory used for constructing tokens.</remarks>
-		ITokenFactory GetTokenFactory();
-
 		/// <summary>Optional method that lets users set factory in lexer or other source</summary>
-		void SetTokenFactory(ITokenFactory factory);
+		ITokenFactory TokenFactory
+		{
+			get;
+			set;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/ITokenStream.cs b/Antlr4.Runtime/ITokenStream.cs
index 1859f79f5..596b77867 100644
--- a/Antlr4.Runtime/ITokenStream.cs
+++ b/Antlr4.Runtime/ITokenStream.cs
@@ -104,8 +104,10 @@ namespace Antlr4.Runtime
 		/// which provides tokens for this
 		/// stream.
 		/// </summary>
-		[NotNull]
-		ITokenSource GetTokenSource();
+		ITokenSource TokenSource
+		{
+			get;
+		}
 
 		/// <summary>
 		/// Return the text of all tokens within the specified
@@ -213,7 +215,7 @@ namespace Antlr4.Runtime
 		/// token, the behavior is unspecified.
 		/// <p/>
 		/// For streams which ensure that the
-		/// <see cref="IToken.GetTokenIndex()">IToken.GetTokenIndex()</see>
+		/// <see cref="IToken.TokenIndex()">IToken.TokenIndex()</see>
 		/// 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
diff --git a/Antlr4.Runtime/IWritableToken.cs b/Antlr4.Runtime/IWritableToken.cs
index 2b02e218e..add55022d 100644
--- a/Antlr4.Runtime/IWritableToken.cs
+++ b/Antlr4.Runtime/IWritableToken.cs
@@ -34,16 +34,34 @@ namespace Antlr4.Runtime
 {
 	public interface IWritableToken : IToken
 	{
-		void SetText(string text);
+		string Text
+		{
+			set;
+		}
 
-		void SetType(int ttype);
+		int Type
+		{
+			set;
+		}
 
-		void SetLine(int line);
+		int Line
+		{
+			set;
+		}
 
-		void SetCharPositionInLine(int pos);
+		int Column
+		{
+			set;
+		}
 
-		void SetChannel(int channel);
+		int Channel
+		{
+			set;
+		}
 
-		void SetTokenIndex(int index);
+		int TokenIndex
+		{
+			set;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/Lexer.cs b/Antlr4.Runtime/Lexer.cs
index 79c7565eb..976248b5d 100644
--- a/Antlr4.Runtime/Lexer.cs
+++ b/Antlr4.Runtime/Lexer.cs
@@ -179,7 +179,7 @@ namespace Antlr4.Runtime
 					}
 					_token = null;
 					_channel = IToken.DefaultChannel;
-					_tokenStartCharIndex = _input.Index();
+					_tokenStartCharIndex = _input.Index;
 					_tokenStartCharPositionInLine = GetInterpreter().GetCharPositionInLine();
 					_tokenStartLine = GetInterpreter().GetLine();
 					_text = null;
@@ -274,14 +274,17 @@ outer_break: ;
 			return _mode;
 		}
 
-		public virtual ITokenFactory GetTokenFactory()
+		public virtual ITokenFactory TokenFactory
 		{
-			return _factory;
-		}
-
-		public virtual void SetTokenFactory(ITokenFactory factory)
-		{
-			this._factory = factory;
+			get
+			{
+				return _factory;
+			}
+			set
+			{
+				ITokenFactory factory = value;
+				this._factory = factory;
+			}
 		}
 
 		/// <summary>Set the char stream and reset the lexer</summary>
@@ -294,9 +297,12 @@ outer_break: ;
 			this._tokenFactorySourcePair = Tuple.Create(this, _input);
 		}
 
-		public virtual string GetSourceName()
+		public virtual string SourceName
 		{
-			return _input.GetSourceName();
+			get
+			{
+				return _input.SourceName;
+			}
 		}
 
 		public override IIntStream GetInputStream()
@@ -341,28 +347,34 @@ outer_break: ;
 
 		public virtual IToken EmitEOF()
 		{
-			int cpos = GetCharPositionInLine();
+			int cpos = Column;
 			// 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 n = _token.StopIndex - _token.StartIndex + 1;
+				cpos = _token.Column + n;
 			}
 			IToken eof = _factory.Create(_tokenFactorySourcePair, IToken.Eof, null, IToken.DefaultChannel
-				, _input.Index(), _input.Index() - 1, GetLine(), cpos);
+				, _input.Index, _input.Index - 1, Line, cpos);
 			Emit(eof);
 			return eof;
 		}
 
-		public virtual int GetLine()
+		public virtual int Line
 		{
-			return GetInterpreter().GetLine();
+			get
+			{
+				return GetInterpreter().GetLine();
+			}
 		}
 
-		public virtual int GetCharPositionInLine()
+		public virtual int Column
 		{
-			return GetInterpreter().GetCharPositionInLine();
+			get
+			{
+				return GetInterpreter().GetCharPositionInLine();
+			}
 		}
 
 		public virtual void SetLine(int line)
@@ -378,7 +390,7 @@ outer_break: ;
 		/// <summary>What is the index of the current character of lookahead?</summary>
 		public virtual int GetCharIndex()
 		{
-			return _input.Index();
+			return _input.Index;
 		}
 
 		/// <summary>
@@ -471,7 +483,7 @@ outer_break: ;
 		{
 			IList<IToken> tokens = new List<IToken>();
 			IToken t = NextToken();
-			while (t.GetType() != IToken.Eof)
+			while (t.Type != IToken.Eof)
 			{
 				tokens.AddItem(t);
 				t = NextToken();
@@ -490,7 +502,7 @@ outer_break: ;
 
 		public virtual void NotifyListeners(LexerNoViableAltException e)
 		{
-			string text = _input.GetText(Interval.Of(_tokenStartCharIndex, _input.Index()));
+			string text = _input.GetText(Interval.Of(_tokenStartCharIndex, _input.Index));
 			string msg = "token recognition error at: '" + GetErrorDisplay(text) + "'";
 			IAntlrErrorListener<int> listener = GetErrorListenerDispatch();
 			listener.SyntaxError(this, null, _tokenStartLine, _tokenStartCharPositionInLine, 
diff --git a/Antlr4.Runtime/LexerNoViableAltException.cs b/Antlr4.Runtime/LexerNoViableAltException.cs
index f329cbd2b..fa5d19b6d 100644
--- a/Antlr4.Runtime/LexerNoViableAltException.cs
+++ b/Antlr4.Runtime/LexerNoViableAltException.cs
@@ -73,7 +73,7 @@ namespace Antlr4.Runtime
 		public override string ToString()
 		{
 			string symbol = string.Empty;
-			if (startIndex >= 0 && startIndex < ((ICharStream)GetInputStream()).Size())
+			if (startIndex >= 0 && startIndex < ((ICharStream)GetInputStream()).Size)
 			{
 				symbol = ((ICharStream)GetInputStream()).GetText(Interval.Of(startIndex, startIndex
 					));
diff --git a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
index 27269ac3a..1d2c4f61b 100644
--- a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
+++ b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
@@ -742,7 +742,7 @@ namespace Antlr4.Runtime.Misc
 				}
 				foreach (Transition transition in state.GetTransitions())
 				{
-					if (transition.GetSerializationType() != Transition.Rule)
+					if (transition.SerializationType != Transition.Rule)
 					{
 						continue;
 					}
diff --git a/Antlr4.Runtime/Parser.cs b/Antlr4.Runtime/Parser.cs
index e447ee8bc..562c0205a 100644
--- a/Antlr4.Runtime/Parser.cs
+++ b/Antlr4.Runtime/Parser.cs
@@ -49,13 +49,13 @@ namespace Antlr4.Runtime
 			public virtual void EnterEveryRule(ParserRuleContext ctx)
 			{
 				System.Console.Out.WriteLine("enter   " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
-					()] + ", LT(1)=" + this._enclosing._input.Lt(1).GetText());
+					()] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
 			}
 
 			public virtual void ExitEveryRule(ParserRuleContext ctx)
 			{
 				System.Console.Out.WriteLine("exit    " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
-					()] + ", LT(1)=" + this._enclosing._input.Lt(1).GetText());
+					()] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
 			}
 
 			public virtual void VisitErrorNode(IErrorNode node)
@@ -64,8 +64,8 @@ namespace Antlr4.Runtime
 
 			public virtual void VisitTerminal(ITerminalNode node)
 			{
-				ParserRuleContext parent = (ParserRuleContext)node.GetParent().GetRuleContext();
-				IToken token = node.GetSymbol();
+				ParserRuleContext parent = (ParserRuleContext)((IRuleNode)node.Parent).RuleContext;
+				IToken token = node.Symbol;
 				System.Console.Out.WriteLine("consume " + token + " rule " + this._enclosing.GetRuleNames
 					()[parent.GetRuleIndex()] + " alt=" + parent.altNum);
 			}
@@ -182,7 +182,7 @@ namespace Antlr4.Runtime
 		public virtual IToken Match(int ttype)
 		{
 			IToken t = GetCurrentToken();
-			if (t.GetType() == ttype)
+			if (t.Type == ttype)
 			{
 				_errHandler.EndErrorCondition(this);
 				Consume();
@@ -190,7 +190,7 @@ namespace Antlr4.Runtime
 			else
 			{
 				t = _errHandler.RecoverInline(this);
-				if (_buildParseTrees && t.GetTokenIndex() == -1)
+				if (_buildParseTrees && t.TokenIndex == -1)
 				{
 					// we must have conjured up a new token during single token insertion
 					// if it's not the current symbol
@@ -204,7 +204,7 @@ namespace Antlr4.Runtime
 		public virtual IToken MatchWildcard()
 		{
 			IToken t = GetCurrentToken();
-			if (t.GetType() > 0)
+			if (t.Type > 0)
 			{
 				_errHandler.EndErrorCondition(this);
 				Consume();
@@ -212,7 +212,7 @@ namespace Antlr4.Runtime
 			else
 			{
 				t = _errHandler.RecoverInline(this);
-				if (_buildParseTrees && t.GetTokenIndex() == -1)
+				if (_buildParseTrees && t.TokenIndex == -1)
 				{
 					// we must have conjured up a new token during single token insertion
 					// if it's not the current symbol
@@ -464,8 +464,8 @@ namespace Antlr4.Runtime
 			int charPositionInLine = -1;
 			if (offendingToken != null)
 			{
-				line = offendingToken.GetLine();
-				charPositionInLine = offendingToken.GetCharPositionInLine();
+				line = offendingToken.Line;
+				charPositionInLine = offendingToken.Column;
 			}
 			IAntlrErrorListener<IToken> listener = ((IParserErrorListener)GetErrorListenerDispatch
 				());
@@ -486,7 +486,7 @@ namespace Antlr4.Runtime
 		public virtual IToken Consume()
 		{
 			IToken o = GetCurrentToken();
-			if (o.GetType() != Eof)
+			if (o.Type != Eof)
 			{
 				((ITokenStream)GetInputStream()).Consume();
 			}
@@ -559,8 +559,8 @@ namespace Antlr4.Runtime
 			SetState(state);
 			if (_buildParseTrees)
 			{
-				ParserRuleContext factoredContext = (ParserRuleContext)_ctx.GetChild(_ctx.GetChildCount
-					() - 1);
+				ParserRuleContext factoredContext = (ParserRuleContext)_ctx.GetChild(_ctx.ChildCount
+					 - 1);
 				_ctx.RemoveLastChild();
 				factoredContext.parent = localctx;
 				localctx.AddChild(factoredContext);
@@ -868,7 +868,7 @@ namespace Antlr4.Runtime
 
 		public virtual string GetSourceName()
 		{
-			return _input.GetSourceName();
+			return _input.SourceName;
 		}
 
 		/// <summary>A convenience method for use most often with template rewrites.</summary>
@@ -885,7 +885,7 @@ namespace Antlr4.Runtime
 			IList<string> strings = new List<string>(tokens.Count);
 			for (int i = 0; i < tokens.Count; i++)
 			{
-				strings.AddItem(tokens[i].GetText());
+				strings.AddItem(tokens[i].Text);
 			}
 			return strings;
 		}
diff --git a/Antlr4.Runtime/ParserRuleContext.cs b/Antlr4.Runtime/ParserRuleContext.cs
index 8ef9212c3..14e660ec8 100644
--- a/Antlr4.Runtime/ParserRuleContext.cs
+++ b/Antlr4.Runtime/ParserRuleContext.cs
@@ -223,9 +223,12 @@ namespace Antlr4.Runtime
 			return t;
 		}
 
-		public override RuleContext GetParent()
+		public override RuleContext Parent
 		{
-			return (Antlr4.Runtime.ParserRuleContext)base.GetParent();
+			get
+			{
+				return (Antlr4.Runtime.ParserRuleContext)base.Parent;
+			}
 		}
 
 		public override IParseTree GetChild(int i)
@@ -269,8 +272,8 @@ namespace Antlr4.Runtime
 				if (o is ITerminalNode)
 				{
 					ITerminalNode tnode = (ITerminalNode)o;
-					IToken symbol = tnode.GetSymbol();
-					if (symbol.GetType() == ttype)
+					IToken symbol = tnode.Symbol;
+					if (symbol.Type == ttype)
 					{
 						j++;
 						if (j == i)
@@ -295,8 +298,8 @@ namespace Antlr4.Runtime
 				if (o is ITerminalNode)
 				{
 					ITerminalNode tnode = (ITerminalNode)o;
-					IToken symbol = tnode.GetSymbol();
-					if (symbol.GetType() == ttype)
+					IToken symbol = tnode.Symbol;
+					if (symbol.Type == ttype)
 					{
 						if (tokens == null)
 						{
@@ -345,18 +348,24 @@ namespace Antlr4.Runtime
 			return contexts;
 		}
 
-		public override int GetChildCount()
+		public override int ChildCount
 		{
-			return children != null ? children.Count : 0;
+			get
+			{
+				return children != null ? children.Count : 0;
+			}
 		}
 
-		public override Interval GetSourceInterval()
+		public override Interval SourceInterval
 		{
-			if (start == null || stop == null)
+			get
 			{
-				return Interval.Invalid;
+				if (start == null || stop == null)
+				{
+					return Interval.Invalid;
+				}
+				return Interval.Of(start.TokenIndex, stop.TokenIndex);
 			}
-			return Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex());
 		}
 
 		public virtual IToken GetStart()
diff --git a/Antlr4.Runtime/Recognizer`2.cs b/Antlr4.Runtime/Recognizer`2.cs
index 0dc8d6fdd..aa7e5851e 100644
--- a/Antlr4.Runtime/Recognizer`2.cs
+++ b/Antlr4.Runtime/Recognizer`2.cs
@@ -96,8 +96,8 @@ namespace Antlr4.Runtime
 		/// <summary>What is the error header, normally line/character position information?</summary>
 		public virtual string GetErrorHeader(RecognitionException e)
 		{
-			int line = e.GetOffendingToken().GetLine();
-			int charPositionInLine = e.GetOffendingToken().GetCharPositionInLine();
+			int line = e.GetOffendingToken().Line;
+			int charPositionInLine = e.GetOffendingToken().Column;
 			return "line " + line + ":" + charPositionInLine;
 		}
 
@@ -121,16 +121,16 @@ namespace Antlr4.Runtime
 			{
 				return "<no token>";
 			}
-			string s = t.GetText();
+			string s = t.Text;
 			if (s == null)
 			{
-				if (t.GetType() == IToken.Eof)
+				if (t.Type == IToken.Eof)
 				{
 					s = "<EOF>";
 				}
 				else
 				{
-					s = "<" + t.GetType() + ">";
+					s = "<" + t.Type + ">";
 				}
 			}
 			s = s.ReplaceAll("\n", "\\\\n");
diff --git a/Antlr4.Runtime/RuleContext.cs b/Antlr4.Runtime/RuleContext.cs
index e104b68e2..bb68d2482 100644
--- a/Antlr4.Runtime/RuleContext.cs
+++ b/Antlr4.Runtime/RuleContext.cs
@@ -116,25 +116,37 @@ namespace Antlr4.Runtime
 			return invokingState == -1;
 		}
 
-		// satisfy the ParseTree / SyntaxTree interface
-		public virtual Interval GetSourceInterval()
+		public virtual Interval SourceInterval
 		{
-			return Interval.Invalid;
+			get
+			{
+				// satisfy the ParseTree / SyntaxTree interface
+				return Interval.Invalid;
+			}
 		}
 
-		public virtual Antlr4.Runtime.RuleContext GetRuleContext()
+		public virtual Antlr4.Runtime.RuleContext RuleContext
 		{
-			return this;
+			get
+			{
+				return this;
+			}
 		}
 
-		public virtual Antlr4.Runtime.RuleContext GetParent()
+		public virtual Antlr4.Runtime.RuleContext Parent
 		{
-			return parent;
+			get
+			{
+				return parent;
+			}
 		}
 
-		public virtual Antlr4.Runtime.RuleContext GetPayload()
+		public virtual Antlr4.Runtime.RuleContext Payload
 		{
-			return this;
+			get
+			{
+				return this;
+			}
 		}
 
 		/// <summary>Return the combined text of all child nodes.</summary>
@@ -148,12 +160,12 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		public virtual string GetText()
 		{
-			if (GetChildCount() == 0)
+			if (ChildCount == 0)
 			{
 				return string.Empty;
 			}
 			StringBuilder builder = new StringBuilder();
-			for (int i = 0; i < GetChildCount(); i++)
+			for (int i = 0; i < ChildCount; i++)
 			{
 				builder.Append(GetChild(i).GetText());
 			}
@@ -170,9 +182,12 @@ namespace Antlr4.Runtime
 			return null;
 		}
 
-		public virtual int GetChildCount()
+		public virtual int ChildCount
 		{
-			return 0;
+			get
+			{
+				return 0;
+			}
 		}
 
 		public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
diff --git a/Antlr4.Runtime/TokenStreamRewriter.cs b/Antlr4.Runtime/TokenStreamRewriter.cs
index 95cb4c017..ac71f1744 100644
--- a/Antlr4.Runtime/TokenStreamRewriter.cs
+++ b/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -156,9 +156,9 @@ namespace Antlr4.Runtime
 			public override int Execute(StringBuilder buf)
 			{
 				buf.Append(text);
-				if (tokens.Get(index).GetType() != IToken.Eof)
+				if (tokens.Get(index).Type != IToken.Eof)
 				{
-					buf.Append(tokens.Get(index).GetText());
+					buf.Append(tokens.Get(index).Text);
 				}
 				return index + 1;
 			}
@@ -278,7 +278,7 @@ namespace Antlr4.Runtime
 
 		public virtual void InsertAfter(string programName, IToken t, object text)
 		{
-			InsertAfter(programName, t.GetTokenIndex(), text);
+			InsertAfter(programName, t.TokenIndex, text);
 		}
 
 		public virtual void InsertAfter(string programName, int index, object text)
@@ -299,7 +299,7 @@ namespace Antlr4.Runtime
 
 		public virtual void InsertBefore(string programName, IToken t, object text)
 		{
-			InsertBefore(programName, t.GetTokenIndex(), text);
+			InsertBefore(programName, t.TokenIndex, text);
 		}
 
 		public virtual void InsertBefore(string programName, int index, object text)
@@ -333,10 +333,10 @@ namespace Antlr4.Runtime
 
 		public virtual void Replace(string programName, int from, int to, object text)
 		{
-			if (from > to || from < 0 || to < 0 || to >= tokens.Size())
+			if (from > to || from < 0 || to < 0 || to >= tokens.Size)
 			{
 				throw new ArgumentException("replace: range invalid: " + from + ".." + to + "(size="
-					 + tokens.Size() + ")");
+					 + tokens.Size + ")");
 			}
 			TokenStreamRewriter.RewriteOperation op = new TokenStreamRewriter.ReplaceOp(tokens
 				, from, to, text);
@@ -348,7 +348,7 @@ namespace Antlr4.Runtime
 		public virtual void Replace(string programName, IToken from, IToken to, object text
 			)
 		{
-			Replace(programName, from.GetTokenIndex(), to.GetTokenIndex(), text);
+			Replace(programName, from.TokenIndex, to.TokenIndex, text);
 		}
 
 		public virtual void Delete(int index)
@@ -432,7 +432,7 @@ namespace Antlr4.Runtime
 		/// </remarks>
 		public virtual string GetText()
 		{
-			return GetText(DefaultProgramName, Interval.Of(0, tokens.Size() - 1));
+			return GetText(DefaultProgramName, Interval.Of(0, tokens.Size - 1));
 		}
 
 		/// <summary>
@@ -460,9 +460,9 @@ namespace Antlr4.Runtime
 			int start = interval.a;
 			int stop = interval.b;
 			// ensure start/end are in range
-			if (stop > tokens.Size() - 1)
+			if (stop > tokens.Size - 1)
 			{
-				stop = tokens.Size() - 1;
+				stop = tokens.Size - 1;
 			}
 			if (start < 0)
 			{
@@ -479,7 +479,7 @@ namespace Antlr4.Runtime
 				(rewrites);
 			// Walk buffer, executing instructions and emitting tokens
 			int i = start;
-			while (i <= stop && i < tokens.Size())
+			while (i <= stop && i < tokens.Size)
 			{
 				TokenStreamRewriter.RewriteOperation op = indexToOp.Get(i);
 				Sharpen.Collections.Remove(indexToOp, i);
@@ -488,9 +488,9 @@ namespace Antlr4.Runtime
 				if (op == null)
 				{
 					// no operation at that index, just dump token
-					if (t.GetType() != IToken.Eof)
+					if (t.Type != IToken.Eof)
 					{
-						buf.Append(t.GetText());
+						buf.Append(t.Text);
 					}
 					i++;
 				}
@@ -504,13 +504,13 @@ namespace Antlr4.Runtime
 			// 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)
+			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)
+					if (op.index >= tokens.Size - 1)
 					{
 						buf.Append(op.text);
 					}
diff --git a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
index 49c80b829..1e5b6150d 100644
--- a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
+++ b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
@@ -72,7 +72,7 @@ namespace Antlr4.Runtime.Tree
 		public virtual Result VisitChildren(IRuleNode node)
 		{
 			Result result = DefaultResult();
-			int n = node.GetChildCount();
+			int n = node.ChildCount;
 			for (int i = 0; i < n; i++)
 			{
 				if (!ShouldVisitNextChild(node, result))
diff --git a/Antlr4.Runtime/Tree/IParseTree.cs b/Antlr4.Runtime/Tree/IParseTree.cs
index 2f02430b2..d6530fcf3 100644
--- a/Antlr4.Runtime/Tree/IParseTree.cs
+++ b/Antlr4.Runtime/Tree/IParseTree.cs
@@ -49,9 +49,12 @@ namespace Antlr4.Runtime.Tree
 	/// </summary>
 	public interface IParseTree : ISyntaxTree
 	{
-		// the following methods narrow the return type; they are not additional methods
-		IParseTree GetParent();
+		IParseTree Parent
+		{
+			get;
+		}
 
+		// the following methods narrow the return type; they are not additional methods
 		IParseTree GetChild(int i);
 
 		/// <summary>
diff --git a/Antlr4.Runtime/Tree/IRuleNode.cs b/Antlr4.Runtime/Tree/IRuleNode.cs
index 33cbdc9ae..c7098d0d6 100644
--- a/Antlr4.Runtime/Tree/IRuleNode.cs
+++ b/Antlr4.Runtime/Tree/IRuleNode.cs
@@ -27,7 +27,6 @@
  *  (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.Tree;
 using Sharpen;
 
@@ -35,8 +34,14 @@ namespace Antlr4.Runtime.Tree
 {
 	public interface IRuleNode : IParseTree
 	{
-		RuleContext GetRuleContext();
+		Antlr4.Runtime.RuleContext RuleContext
+		{
+			get;
+		}
 
-		IRuleNode GetParent();
+		IRuleNode Parent
+		{
+			get;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/Tree/ISyntaxTree.cs b/Antlr4.Runtime/Tree/ISyntaxTree.cs
index 2ad7e3a5f..ef2ca13f1 100644
--- a/Antlr4.Runtime/Tree/ISyntaxTree.cs
+++ b/Antlr4.Runtime/Tree/ISyntaxTree.cs
@@ -58,7 +58,9 @@ namespace Antlr4.Runtime.Tree
 		/// 	</see>
 		/// .
 		/// </summary>
-		[NotNull]
-		Interval GetSourceInterval();
+		Interval SourceInterval
+		{
+			get;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/Tree/ITerminalNode.cs b/Antlr4.Runtime/Tree/ITerminalNode.cs
index 7103956ae..b086eb541 100644
--- a/Antlr4.Runtime/Tree/ITerminalNode.cs
+++ b/Antlr4.Runtime/Tree/ITerminalNode.cs
@@ -35,8 +35,14 @@ namespace Antlr4.Runtime.Tree
 {
 	public interface ITerminalNode : IParseTree
 	{
-		IToken GetSymbol();
+		IToken Symbol
+		{
+			get;
+		}
 
-		IRuleNode GetParent();
+		IRuleNode Parent
+		{
+			get;
+		}
 	}
 }
diff --git a/Antlr4.Runtime/Tree/ITree.cs b/Antlr4.Runtime/Tree/ITree.cs
index 66d065007..f71b11c59 100644
--- a/Antlr4.Runtime/Tree/ITree.cs
+++ b/Antlr4.Runtime/Tree/ITree.cs
@@ -45,7 +45,10 @@ namespace Antlr4.Runtime.Tree
 		/// The parent of this node. If the return value is null, then this
 		/// node is the root of the tree.
 		/// </remarks>
-		ITree GetParent();
+		ITree Parent
+		{
+			get;
+		}
 
 		/// <summary>This method returns whatever object represents the data at this note.</summary>
 		/// <remarks>
@@ -60,7 +63,10 @@ namespace Antlr4.Runtime.Tree
 		/// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
 		/// object.
 		/// </remarks>
-		object GetPayload();
+		object Payload
+		{
+			get;
+		}
 
 		/// <summary>
 		/// If there are children, get the
@@ -77,7 +83,10 @@ namespace Antlr4.Runtime.Tree
 		/// How many children are there? If there is none, then this
 		/// node represents a leaf node.
 		/// </remarks>
-		int GetChildCount();
+		int ChildCount
+		{
+			get;
+		}
 
 		/// <summary>
 		/// Print out a whole tree, not just a node, in LISP format
diff --git a/Antlr4.Runtime/Tree/ParseTreeWalker.cs b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
index c2f3e42dc..53e0a1673 100644
--- a/Antlr4.Runtime/Tree/ParseTreeWalker.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
@@ -54,7 +54,7 @@ namespace Antlr4.Runtime.Tree
 			}
 			IRuleNode r = (IRuleNode)t;
 			EnterRule(listener, r);
-			int n = r.GetChildCount();
+			int n = r.ChildCount;
 			for (int i = 0; i < n; i++)
 			{
 				Walk(listener, r.GetChild(i));
@@ -74,7 +74,7 @@ namespace Antlr4.Runtime.Tree
 		protected internal virtual void EnterRule(IParseTreeListener listener, IRuleNode 
 			r)
 		{
-			ParserRuleContext ctx = (ParserRuleContext)r.GetRuleContext();
+			ParserRuleContext ctx = (ParserRuleContext)r.RuleContext;
 			listener.EnterEveryRule(ctx);
 			ctx.EnterRule(listener);
 		}
@@ -82,7 +82,7 @@ namespace Antlr4.Runtime.Tree
 		protected internal virtual void ExitRule(IParseTreeListener listener, IRuleNode r
 			)
 		{
-			ParserRuleContext ctx = (ParserRuleContext)r.GetRuleContext();
+			ParserRuleContext ctx = (ParserRuleContext)r.RuleContext;
 			ctx.ExitRule(listener);
 			listener.ExitEveryRule(ctx);
 		}
diff --git a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
index c5dc2d319..db338eb15 100644
--- a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
@@ -50,34 +50,49 @@ namespace Antlr4.Runtime.Tree
 			return null;
 		}
 
-		public virtual IToken GetSymbol()
+		public virtual IToken Symbol
 		{
-			return symbol;
-		}
-
-		public virtual IRuleNode GetParent()
-		{
-			return parent;
-		}
-
-		public virtual IToken GetPayload()
-		{
-			return symbol;
-		}
-
-		public virtual Interval GetSourceInterval()
-		{
-			if (symbol != null)
+			get
 			{
-				int tokenIndex = symbol.GetTokenIndex();
-				return new Interval(tokenIndex, tokenIndex);
+				return symbol;
 			}
-			return Interval.Invalid;
 		}
 
-		public virtual int GetChildCount()
+		public virtual IRuleNode Parent
 		{
-			return 0;
+			get
+			{
+				return parent;
+			}
+		}
+
+		public virtual IToken Payload
+		{
+			get
+			{
+				return symbol;
+			}
+		}
+
+		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, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
@@ -89,7 +104,7 @@ namespace Antlr4.Runtime.Tree
 		{
 			if (symbol != null)
 			{
-				return symbol.GetText();
+				return symbol.Text;
 			}
 			return null;
 		}
@@ -103,11 +118,11 @@ namespace Antlr4.Runtime.Tree
 		{
 			if (symbol != null)
 			{
-				if (symbol.GetType() == IToken.Eof)
+				if (symbol.Type == IToken.Eof)
 				{
 					return "<EOF>";
 				}
-				return symbol.GetText();
+				return symbol.Text;
 			}
 			else
 			{
diff --git a/Antlr4.Runtime/Tree/Trees.cs b/Antlr4.Runtime/Tree/Trees.cs
index 2cf658eb4..73166a88a 100644
--- a/Antlr4.Runtime/Tree/Trees.cs
+++ b/Antlr4.Runtime/Tree/Trees.cs
@@ -114,7 +114,7 @@ namespace Antlr4.Runtime.Tree
 		public static string ToStringTree(ITree t, IList<string> ruleNames)
 		{
 			string s = Utils.EscapeWhitespace(GetNodeText(t, ruleNames), false);
-			if (t.GetChildCount() == 0)
+			if (t.ChildCount == 0)
 			{
 				return s;
 			}
@@ -123,7 +123,7 @@ namespace Antlr4.Runtime.Tree
 			s = Utils.EscapeWhitespace(GetNodeText(t, ruleNames), false);
 			buf.Append(s);
 			buf.Append(' ');
-			for (int i = 0; i < t.GetChildCount(); i++)
+			for (int i = 0; i < t.ChildCount; i++)
 			{
 				if (i > 0)
 				{
@@ -148,7 +148,7 @@ namespace Antlr4.Runtime.Tree
 			{
 				if (t is IRuleNode)
 				{
-					int ruleIndex = ((IRuleNode)t).GetRuleContext().GetRuleIndex();
+					int ruleIndex = ((IRuleNode)t).RuleContext.GetRuleIndex();
 					string ruleName = ruleNames[ruleIndex];
 					return ruleName;
 				}
@@ -162,10 +162,10 @@ namespace Antlr4.Runtime.Tree
 					{
 						if (t is ITerminalNode)
 						{
-							object symbol = ((ITerminalNode)t).GetSymbol();
+							object symbol = ((ITerminalNode)t).Symbol;
 							if (symbol is IToken)
 							{
-								string s = ((IToken)symbol).GetText();
+								string s = ((IToken)symbol).Text;
 								return s;
 							}
 						}
@@ -173,12 +173,12 @@ namespace Antlr4.Runtime.Tree
 				}
 			}
 			// no recog for rule names
-			object payload = t.GetPayload();
+			object payload = t.Payload;
 			if (payload is IToken)
 			{
-				return ((IToken)payload).GetText();
+				return ((IToken)payload).Text;
 			}
-			return t.GetPayload().ToString();
+			return t.Payload.ToString();
 		}
 
 		/// <summary>Return a list of all ancestors of this node.</summary>
@@ -189,17 +189,17 @@ namespace Antlr4.Runtime.Tree
 		[NotNull]
 		public static IList<ITree> GetAncestors(ITree t)
 		{
-			if (t.GetParent() == null)
+			if (t.Parent == null)
 			{
 				return Sharpen.Collections.EmptyList();
 			}
 			IList<ITree> ancestors = new List<ITree>();
-			t = t.GetParent();
+			t = t.Parent;
 			while (t != null)
 			{
 				ancestors.Add(0, t);
 				// insert at start
-				t = t.GetParent();
+				t = t.Parent;
 			}
 			return ancestors;
 		}
diff --git a/Antlr4.Runtime/UnbufferedCharStream.cs b/Antlr4.Runtime/UnbufferedCharStream.cs
index cbcd8fe1e..d690cf52c 100644
--- a/Antlr4.Runtime/UnbufferedCharStream.cs
+++ b/Antlr4.Runtime/UnbufferedCharStream.cs
@@ -342,9 +342,12 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		public virtual int Index()
+		public virtual int Index
 		{
-			return currentCharIndex;
+			get
+			{
+				return currentCharIndex;
+			}
 		}
 
 		/// <summary>
@@ -396,14 +399,20 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		public virtual int Size()
+		public virtual int Size
 		{
-			throw new NotSupportedException("Unbuffered stream cannot know its size");
+			get
+			{
+				throw new NotSupportedException("Unbuffered stream cannot know its size");
+			}
 		}
 
-		public virtual string GetSourceName()
+		public virtual string SourceName
 		{
-			return name;
+			get
+			{
+				return name;
+			}
 		}
 
 		public override string GetText(Interval interval)
diff --git a/Antlr4.Runtime/UnbufferedTokenStream.cs b/Antlr4.Runtime/UnbufferedTokenStream.cs
index 1c4942ecb..3b0d385ab 100644
--- a/Antlr4.Runtime/UnbufferedTokenStream.cs
+++ b/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -167,7 +167,7 @@ namespace Antlr4.Runtime
 			}
 			if (index >= n)
 			{
-				System.Diagnostics.Debug.Assert(n > 0 && tokens[n - 1].GetType() == IToken.Eof);
+				System.Diagnostics.Debug.Assert(n > 0 && tokens[n - 1].Type == IToken.Eof);
 				return tokens[n - 1];
 			}
 			return tokens[index];
@@ -175,12 +175,15 @@ namespace Antlr4.Runtime
 
 		public virtual int La(int i)
 		{
-			return Lt(i).GetType();
+			return Lt(i).Type;
 		}
 
-		public virtual ITokenSource GetTokenSource()
+		public virtual ITokenSource TokenSource
 		{
-			return tokenSource;
+			get
+			{
+				return tokenSource;
+			}
 		}
 
 		[NotNull]
@@ -192,7 +195,7 @@ namespace Antlr4.Runtime
 		[NotNull]
 		public virtual string GetText(RuleContext ctx)
 		{
-			return GetText(ctx.GetSourceInterval());
+			return GetText(ctx.SourceInterval);
 		}
 
 		[NotNull]
@@ -200,7 +203,7 @@ namespace Antlr4.Runtime
 		{
 			if (start != null && stop != null)
 			{
-				return GetText(Interval.Of(start.GetTokenIndex(), stop.GetTokenIndex()));
+				return GetText(Interval.Of(start.TokenIndex, stop.TokenIndex));
 			}
 			throw new NotSupportedException("The specified start and stop symbols are not supported."
 				);
@@ -269,7 +272,7 @@ namespace Antlr4.Runtime
 		{
 			for (int i = 0; i < n; i++)
 			{
-				if (this.n > 0 && tokens[this.n - 1].GetType() == IToken.Eof)
+				if (this.n > 0 && tokens[this.n - 1].Type == IToken.Eof)
 				{
 					return i;
 				}
@@ -287,7 +290,7 @@ namespace Antlr4.Runtime
 			}
 			if (t is IWritableToken)
 			{
-				((IWritableToken)t).SetTokenIndex(GetBufferStartIndex() + n);
+				((IWritableToken)t).TokenIndex = GetBufferStartIndex() + n;
 			}
 			tokens[n++] = t;
 		}
@@ -338,9 +341,12 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		public virtual int Index()
+		public virtual int Index
 		{
-			return currentTokenIndex;
+			get
+			{
+				return currentTokenIndex;
+			}
 		}
 
 		public virtual void Seek(int index)
@@ -381,14 +387,20 @@ namespace Antlr4.Runtime
 			}
 		}
 
-		public virtual int Size()
+		public virtual int Size
 		{
-			throw new NotSupportedException("Unbuffered stream cannot know its size");
+			get
+			{
+				throw new NotSupportedException("Unbuffered stream cannot know its size");
+			}
 		}
 
-		public virtual string GetSourceName()
+		public virtual string SourceName
 		{
-			return tokenSource.GetSourceName();
+			get
+			{
+				return tokenSource.SourceName;
+			}
 		}
 
 		[NotNull]
@@ -409,7 +421,7 @@ namespace Antlr4.Runtime
 			for (int i = a; i <= b; i++)
 			{
 				IToken t = tokens[i];
-				buf.Append(t.GetText());
+				buf.Append(t.Text);
 			}
 			return buf.ToString();
 		}
diff --git a/reference/antlr4 b/reference/antlr4
index c7dc3828f..88652241c 160000
--- a/reference/antlr4
+++ b/reference/antlr4
@@ -1 +1 @@
-Subproject commit c7dc3828fc49781d3015565db387f37c38137ee6
+Subproject commit 88652241cf2c248a66307e5866be98e3910b6519

From 12d092143fce332ed42658af869f205c28400b75 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Sat, 16 Feb 2013 08:11:56 -0600
Subject: [PATCH 08/10] Map IndexOutOfRangeException to
 ArgumentOutOfRangeException

---
 Antlr4.Runtime/Atn/EmptyPredictionContext.cs |  4 ++--
 Antlr4.Runtime/BufferedTokenStream.cs        | 14 +++++++-------
 Antlr4.Runtime/UnbufferedCharStream.cs       |  2 +-
 Antlr4.Runtime/UnbufferedTokenStream.cs      |  4 ++--
 reference/sharpen-all-options.txt            |  1 +
 5 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
index e3a9e63bf..86761986a 100644
--- a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
@@ -67,12 +67,12 @@ namespace Antlr4.Runtime.Atn
 
 		public override PredictionContext GetParent(int index)
 		{
-			throw new IndexOutOfRangeException();
+			throw new ArgumentOutOfRangeException();
 		}
 
 		public override int GetReturnState(int index)
 		{
-			throw new IndexOutOfRangeException();
+			throw new ArgumentOutOfRangeException();
 		}
 
 		public override int FindReturnState(int returnState)
diff --git a/Antlr4.Runtime/BufferedTokenStream.cs b/Antlr4.Runtime/BufferedTokenStream.cs
index 61d1edfc4..0bc96bcbe 100644
--- a/Antlr4.Runtime/BufferedTokenStream.cs
+++ b/Antlr4.Runtime/BufferedTokenStream.cs
@@ -242,8 +242,8 @@ namespace Antlr4.Runtime
 		{
 			if (i < 0 || i >= tokens.Count)
 			{
-				throw new IndexOutOfRangeException("token index " + i + " out of range 0.." + (tokens
-					.Count - 1));
+				throw new ArgumentOutOfRangeException("token index " + i + " out of range 0.." + 
+					(tokens.Count - 1));
 			}
 			return tokens[i];
 		}
@@ -386,7 +386,7 @@ namespace Antlr4.Runtime
 			LazyInit();
 			if (start < 0 || stop >= tokens.Count || stop < 0 || start >= tokens.Count)
 			{
-				throw new IndexOutOfRangeException("start " + start + " or stop " + stop + " not in 0.."
+				throw new ArgumentOutOfRangeException("start " + start + " or stop " + stop + " not in 0.."
 					 + (tokens.Count - 1));
 			}
 			if (start > stop)
@@ -494,8 +494,8 @@ namespace Antlr4.Runtime
 			LazyInit();
 			if (tokenIndex < 0 || tokenIndex >= tokens.Count)
 			{
-				throw new IndexOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count - 1
-					));
+				throw new ArgumentOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count 
+					- 1));
 			}
 			int nextOnChannel = NextTokenOnChannel(tokenIndex + 1, Lexer.DefaultTokenChannel);
 			int to;
@@ -539,8 +539,8 @@ namespace Antlr4.Runtime
 			LazyInit();
 			if (tokenIndex < 0 || tokenIndex >= tokens.Count)
 			{
-				throw new IndexOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count - 1
-					));
+				throw new ArgumentOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count 
+					- 1));
 			}
 			int prevOnChannel = PreviousTokenOnChannel(tokenIndex - 1, Lexer.DefaultTokenChannel
 				);
diff --git a/Antlr4.Runtime/UnbufferedCharStream.cs b/Antlr4.Runtime/UnbufferedCharStream.cs
index d690cf52c..328a5131b 100644
--- a/Antlr4.Runtime/UnbufferedCharStream.cs
+++ b/Antlr4.Runtime/UnbufferedCharStream.cs
@@ -282,7 +282,7 @@ namespace Antlr4.Runtime
 			int index = p + i - 1;
 			if (index < 0)
 			{
-				throw new IndexOutOfRangeException();
+				throw new ArgumentOutOfRangeException();
 			}
 			if (index > n)
 			{
diff --git a/Antlr4.Runtime/UnbufferedTokenStream.cs b/Antlr4.Runtime/UnbufferedTokenStream.cs
index 3b0d385ab..0363c27a4 100644
--- a/Antlr4.Runtime/UnbufferedTokenStream.cs
+++ b/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -147,7 +147,7 @@ namespace Antlr4.Runtime
 			int bufferStartIndex = GetBufferStartIndex();
 			if (i < bufferStartIndex || i >= bufferStartIndex + n)
 			{
-				throw new IndexOutOfRangeException("get(" + i + ") outside buffer: " + bufferStartIndex
+				throw new ArgumentOutOfRangeException("get(" + i + ") outside buffer: " + bufferStartIndex
 					 + ".." + (bufferStartIndex + n));
 			}
 			return tokens[i - bufferStartIndex];
@@ -163,7 +163,7 @@ namespace Antlr4.Runtime
 			int index = p + i - 1;
 			if (index < 0)
 			{
-				throw new IndexOutOfRangeException("LT(" + i + ") gives negative index");
+				throw new ArgumentOutOfRangeException("LT(" + i + ") gives negative index");
 			}
 			if (index >= n)
 			{
diff --git a/reference/sharpen-all-options.txt b/reference/sharpen-all-options.txt
index b7cb7a646..9f7e7ff03 100644
--- a/reference/sharpen-all-options.txt
+++ b/reference/sharpen-all-options.txt
@@ -179,6 +179,7 @@
 
 -typeMapping org.antlr.v4.runtime.misc.ParseCancellationException ParseCanceledException
 -typeMapping java.util.concurrent.CancellationException System.OperationCanceledException
+-typeMapping java.lang.IndexOutOfBoundsException ArgumentOutOfRangeException
 
 -typeMapping org.antlr.v4.runtime.misc.Tuple System.Tuple
 -typeMapping org.antlr.v4.runtime.misc.Tuple2<,> System.Tuple

From 3d9c3908b8ed911f8c436821dfa186dc5d626e93 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Sat, 16 Feb 2013 08:14:20 -0600
Subject: [PATCH 09/10] Use spaces instead of tabs

---
 Antlr4.Runtime/ANTLRFileStream.cs             |  120 +-
 Antlr4.Runtime/ANTLRInputStream.cs            |  504 +-
 Antlr4.Runtime/Atn/ATN.cs                     |  310 +-
 Antlr4.Runtime/Atn/ATNConfig.cs               |  930 ++--
 Antlr4.Runtime/Atn/ATNConfigSet.cs            | 1188 ++---
 Antlr4.Runtime/Atn/ATNSimulator.cs            | 1806 +++----
 Antlr4.Runtime/Atn/ATNState.cs                |  444 +-
 .../Atn/AbstractPredicateTransition.cs        |   14 +-
 Antlr4.Runtime/Atn/ActionTransition.cs        |   82 +-
 Antlr4.Runtime/Atn/ArrayPredictionContext.cs  |  460 +-
 Antlr4.Runtime/Atn/AtomTransition.cs          |   68 +-
 Antlr4.Runtime/Atn/BasicBlockStartState.cs    |   16 +-
 Antlr4.Runtime/Atn/BasicState.cs              |   16 +-
 Antlr4.Runtime/Atn/BlockEndState.cs           |   26 +-
 Antlr4.Runtime/Atn/BlockStartState.cs         |   18 +-
 Antlr4.Runtime/Atn/DecisionState.cs           |   12 +-
 Antlr4.Runtime/Atn/EmptyPredictionContext.cs  |  164 +-
 Antlr4.Runtime/Atn/EpsilonTransition.cs       |   58 +-
 Antlr4.Runtime/Atn/LL1Analyzer.cs             |  378 +-
 Antlr4.Runtime/Atn/LexerATNSimulator.cs       | 1308 ++---
 Antlr4.Runtime/Atn/LoopEndState.cs            |   20 +-
 Antlr4.Runtime/Atn/NotSetTransition.cs        |   44 +-
 Antlr4.Runtime/Atn/OrderedATNConfigSet.cs     |   60 +-
 Antlr4.Runtime/Atn/ParserATNPathFinder.cs     |  284 +-
 Antlr4.Runtime/Atn/ParserATNSimulator.cs      | 4287 +++++++++--------
 Antlr4.Runtime/Atn/PlusBlockStartState.cs     |   40 +-
 Antlr4.Runtime/Atn/PlusLoopbackState.cs       |   30 +-
 .../Atn/PrecedencePredicateTransition.cs      |   72 +-
 Antlr4.Runtime/Atn/PredicateTransition.cs     |  104 +-
 Antlr4.Runtime/Atn/PredictionContext.cs       |  936 ++--
 Antlr4.Runtime/Atn/PredictionContextCache.cs  |  322 +-
 Antlr4.Runtime/Atn/RangeTransition.cs         |   66 +-
 Antlr4.Runtime/Atn/RuleStartState.cs          |   20 +-
 Antlr4.Runtime/Atn/RuleStopState.cs           |   38 +-
 Antlr4.Runtime/Atn/RuleTransition.cs          |   74 +-
 Antlr4.Runtime/Atn/SemanticContext.cs         |  692 +--
 Antlr4.Runtime/Atn/SetTransition.cs           |   78 +-
 Antlr4.Runtime/Atn/SimulatorState.cs          |   34 +-
 .../Atn/SingletonPredictionContext.cs         |  174 +-
 Antlr4.Runtime/Atn/StarBlockStartState.cs     |   18 +-
 Antlr4.Runtime/Atn/StarLoopEntryState.cs      |   16 +-
 Antlr4.Runtime/Atn/StarLoopbackState.cs       |   22 +-
 Antlr4.Runtime/Atn/TokensStartState.cs        |   16 +-
 Antlr4.Runtime/Atn/Transition.cs              |  172 +-
 Antlr4.Runtime/Atn/WildcardTransition.cs      |   44 +-
 Antlr4.Runtime/BailErrorStrategy.cs           |  112 +-
 Antlr4.Runtime/BaseErrorListener.cs           |   42 +-
 Antlr4.Runtime/BufferedTokenStream.cs         | 1188 ++---
 Antlr4.Runtime/CommonToken.cs                 |  444 +-
 Antlr4.Runtime/CommonTokenFactory.cs          |  101 +-
 Antlr4.Runtime/CommonTokenStream.cs           |  230 +-
 Antlr4.Runtime/ConsoleErrorListener.cs        |   22 +-
 Antlr4.Runtime/DefaultErrorStrategy.cs        |  966 ++--
 Antlr4.Runtime/Dependents.cs                  |   28 +-
 Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs       |  128 +-
 Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs          |  414 +-
 Antlr4.Runtime/Dfa/DFA.cs                     |  186 +-
 Antlr4.Runtime/Dfa/DFASerializer.cs           |  340 +-
 Antlr4.Runtime/Dfa/DFAState.cs                |  578 +--
 Antlr4.Runtime/Dfa/IEdgeMap`1.cs              |   42 +-
 Antlr4.Runtime/Dfa/LexerDFASerializer.cs      |   22 +-
 Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs      |  344 +-
 Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs         |  448 +-
 Antlr4.Runtime/DiagnosticErrorListener.cs     |   64 +-
 Antlr4.Runtime/FailedPredicateException.cs    |  126 +-
 Antlr4.Runtime/IAntlrErrorListener`1.cs       |   86 +-
 Antlr4.Runtime/IAntlrErrorStrategy.cs         |  232 +-
 Antlr4.Runtime/ICharStream.cs                 |  148 +-
 Antlr4.Runtime/IIntStream.cs                  |  650 +--
 Antlr4.Runtime/IParserErrorListener.cs        |   64 +-
 Antlr4.Runtime/IToken.cs                      |  266 +-
 Antlr4.Runtime/ITokenFactory.cs               |   44 +-
 Antlr4.Runtime/ITokenSource.cs                |  140 +-
 Antlr4.Runtime/ITokenStream.cs                |  410 +-
 Antlr4.Runtime/IWritableToken.cs              |   54 +-
 Antlr4.Runtime/InputMismatchException.cs      |   36 +-
 Antlr4.Runtime/Lexer.cs                       |  956 ++--
 Antlr4.Runtime/LexerNoViableAltException.cs   |   84 +-
 Antlr4.Runtime/Misc/Args.cs                   |   42 +-
 Antlr4.Runtime/Misc/Array2DHashSet`1.cs       | 1216 ++---
 Antlr4.Runtime/Misc/DoubleKeyMap`3.cs         |  132 +-
 Antlr4.Runtime/Misc/FlexibleHashMap`2.cs      |  648 +--
 Antlr4.Runtime/Misc/IFunc0`1.cs               |   10 +-
 Antlr4.Runtime/Misc/IFunc1`2.cs               |   10 +-
 Antlr4.Runtime/Misc/IIntSet.cs                |   86 +-
 Antlr4.Runtime/Misc/IPredicate`1.cs           |   10 +-
 Antlr4.Runtime/Misc/Interval.cs               |  340 +-
 Antlr4.Runtime/Misc/IntervalSet.cs            | 1486 +++---
 Antlr4.Runtime/Misc/MultiMap`2.cs             |   54 +-
 Antlr4.Runtime/Misc/OrderedHashSet`1.cs       |  226 +-
 Antlr4.Runtime/Misc/ParseCanceledException.cs |   64 +-
 Antlr4.Runtime/Misc/RuleDependencyChecker.cs  |  533 +-
 .../Misc/RuleDependencyProcessor.cs           | 1576 +++---
 Antlr4.Runtime/Misc/TestRig.cs                |  562 +--
 Antlr4.Runtime/Misc/Utils.cs                  |  208 +-
 Antlr4.Runtime/NoViableAltException.cs        |  108 +-
 Antlr4.Runtime/Parser.cs                      | 1762 +++----
 Antlr4.Runtime/ParserRuleContext.cs           |  648 +--
 Antlr4.Runtime/ProxyErrorListener`1.cs        |   48 +-
 Antlr4.Runtime/ProxyParserErrorListener.cs    |  100 +-
 Antlr4.Runtime/RecognitionException.cs        |  206 +-
 Antlr4.Runtime/Recognizer`2.cs                |  316 +-
 Antlr4.Runtime/RuleContext.cs                 |  538 +--
 Antlr4.Runtime/TokenStreamRewriter.cs         | 1300 ++---
 .../Tree/AbstractParseTreeVisitor`1.cs        |  384 +-
 Antlr4.Runtime/Tree/ErrorNodeImpl.cs          |   42 +-
 Antlr4.Runtime/Tree/IErrorNode.cs             |    6 +-
 Antlr4.Runtime/Tree/IParseTree.cs             |   90 +-
 Antlr4.Runtime/Tree/IParseTreeListener.cs     |   14 +-
 Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs    |  118 +-
 Antlr4.Runtime/Tree/IRuleNode.cs              |   22 +-
 Antlr4.Runtime/Tree/ISyntaxTree.cs            |   60 +-
 Antlr4.Runtime/Tree/ITerminalNode.cs          |   22 +-
 Antlr4.Runtime/Tree/ITree.cs                  |  118 +-
 Antlr4.Runtime/Tree/ParseTreeProperty`1.cs    |   64 +-
 Antlr4.Runtime/Tree/ParseTreeWalker.cs        |  102 +-
 Antlr4.Runtime/Tree/TerminalNodeImpl.cs       |  176 +-
 Antlr4.Runtime/Tree/Trees.cs                  |  320 +-
 Antlr4.Runtime/UnbufferedCharStream.cs        |  762 +--
 Antlr4.Runtime/UnbufferedTokenStream.cs       |  736 +--
 reference/sharpen                             |    2 +-
 reference/sharpen-all-options.txt             |    1 +
 122 files changed, 19927 insertions(+), 19921 deletions(-)

diff --git a/Antlr4.Runtime/ANTLRFileStream.cs b/Antlr4.Runtime/ANTLRFileStream.cs
index 4e295d7d1..dcb07936e 100644
--- a/Antlr4.Runtime/ANTLRFileStream.cs
+++ b/Antlr4.Runtime/ANTLRFileStream.cs
@@ -32,68 +32,68 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// This is an ANTLRInputStream that is loaded from a file
-	/// all at once when you construct the object.
-	/// </summary>
-	/// <remarks>
-	/// This is an ANTLRInputStream that is loaded from a file
-	/// all at once when you construct the object.  This is a special case
-	/// since we know the exact size of the object to load.  We can avoid lots
-	/// of data copying.
-	/// </remarks>
-	public class AntlrFileStream : AntlrInputStream
-	{
-		protected internal string fileName;
+    /// <summary>
+    /// This is an ANTLRInputStream that is loaded from a file
+    /// all at once when you construct the object.
+    /// </summary>
+    /// <remarks>
+    /// This is an ANTLRInputStream that is loaded from a file
+    /// all at once when you construct the object.  This is a special case
+    /// since we know the exact size of the object to load.  We can avoid lots
+    /// of data copying.
+    /// </remarks>
+    public class AntlrFileStream : AntlrInputStream
+    {
+        protected internal string fileName;
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrFileStream(string fileName) : this(fileName, null)
-		{
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrFileStream(string fileName) : this(fileName, null)
+        {
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrFileStream(string fileName, string encoding)
-		{
-			this.fileName = fileName;
-			Load(fileName, encoding);
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrFileStream(string fileName, string encoding)
+        {
+            this.fileName = fileName;
+            Load(fileName, encoding);
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public virtual void Load(string fileName, string encoding)
-		{
-			if (fileName == null)
-			{
-				return;
-			}
-			FilePath f = new FilePath(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];
-				base.n = isr.Read(data);
-			}
-			finally
-			{
-				isr.Close();
-			}
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public virtual void Load(string fileName, string encoding)
+        {
+            if (fileName == null)
+            {
+                return;
+            }
+            FilePath f = new FilePath(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];
+                base.n = isr.Read(data);
+            }
+            finally
+            {
+                isr.Close();
+            }
+        }
 
-		public override string SourceName
-		{
-			get
-			{
-				return fileName;
-			}
-		}
-	}
+        public override string SourceName
+        {
+            get
+            {
+                return fileName;
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ANTLRInputStream.cs b/Antlr4.Runtime/ANTLRInputStream.cs
index 2b032a116..0574b5f3d 100644
--- a/Antlr4.Runtime/ANTLRInputStream.cs
+++ b/Antlr4.Runtime/ANTLRInputStream.cs
@@ -35,283 +35,283 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>Vacuum all input from a Reader/InputStream and then treat it like a char[] buffer.
-	/// 	</summary>
-	/// <remarks>
-	/// Vacuum all input from a Reader/InputStream and then treat it like a char[] buffer.
-	/// Can also pass in a string or char[] to use.
-	/// If you need encoding, pass in stream/reader with correct encoding.
-	/// </remarks>
-	public class AntlrInputStream : ICharStream
-	{
-		public const int ReadBufferSize = 1024;
+    /// <summary>Vacuum all input from a Reader/InputStream and then treat it like a char[] buffer.
+    ///     </summary>
+    /// <remarks>
+    /// Vacuum all input from a Reader/InputStream and then treat it like a char[] buffer.
+    /// Can also pass in a string or char[] to use.
+    /// If you need encoding, pass in stream/reader with correct encoding.
+    /// </remarks>
+    public class AntlrInputStream : ICharStream
+    {
+        public const int ReadBufferSize = 1024;
 
-		public const int InitialBufferSize = 1024;
+        public const int InitialBufferSize = 1024;
 
-		/// <summary>The data being scanned</summary>
-		protected internal char[] data;
+        /// <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>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>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;
+        /// <summary>What is name or source of this char stream?</summary>
+        public string name;
 
-		public AntlrInputStream()
-		{
-		}
+        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>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;
-		}
+        /// <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"></exception>
-		public AntlrInputStream(StreamReader r) : this(r, InitialBufferSize, ReadBufferSize
-			)
-		{
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrInputStream(StreamReader r) : this(r, InitialBufferSize, ReadBufferSize
+            )
+        {
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrInputStream(StreamReader r, int initialSize) : this(r, initialSize, ReadBufferSize
-			)
-		{
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrInputStream(StreamReader r, int initialSize) : this(r, initialSize, ReadBufferSize
+            )
+        {
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrInputStream(StreamReader r, int initialSize, int readChunkSize)
-		{
-			Load(r, initialSize, readChunkSize);
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrInputStream(StreamReader r, int initialSize, int readChunkSize)
+        {
+            Load(r, initialSize, readChunkSize);
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrInputStream(InputStream input) : this(new InputStreamReader(input), InitialBufferSize
-			)
-		{
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrInputStream(InputStream input) : this(new InputStreamReader(input), InitialBufferSize
+            )
+        {
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrInputStream(InputStream input, int initialSize) : this(new InputStreamReader
-			(input), initialSize)
-		{
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrInputStream(InputStream input, int initialSize) : this(new InputStreamReader
+            (input), initialSize)
+        {
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public AntlrInputStream(InputStream input, int initialSize, int readChunkSize) : 
-			this(new InputStreamReader(input), initialSize, readChunkSize)
-		{
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public AntlrInputStream(InputStream input, int initialSize, int readChunkSize) : 
+            this(new InputStreamReader(input), initialSize, readChunkSize)
+        {
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public virtual void Load(StreamReader r, int size, int readChunkSize)
-		{
-			if (r == null)
-			{
-				return;
-			}
-			if (size <= 0)
-			{
-				size = InitialBufferSize;
-			}
-			if (readChunkSize <= 0)
-			{
-				readChunkSize = ReadBufferSize;
-			}
-			// System.out.println("load "+size+" in chunks of "+readChunkSize);
-			try
-			{
-				// alloc initial buffer size.
-				data = new char[size];
-				// read all the data in chunks of readChunkSize
-				int numRead = 0;
-				int p = 0;
-				do
-				{
-					if (p + readChunkSize > data.Length)
-					{
-						// overflow?
-						// System.out.println("### overflow p="+p+", data.length="+data.length);
-						data = Arrays.CopyOf(data, data.Length * 2);
-					}
-					numRead = r.Read(data, p, readChunkSize);
-					// System.out.println("read "+numRead+" chars; p was "+p+" is now "+(p+numRead));
-					p += numRead;
-				}
-				while (numRead != -1);
-				// while not EOF
-				// set the actual size of the data available;
-				// EOF subtracted one above in p+=numRead; add one back
-				n = p + 1;
-			}
-			finally
-			{
-				//System.out.println("n="+n);
-				r.Close();
-			}
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public virtual void Load(StreamReader r, int size, int readChunkSize)
+        {
+            if (r == null)
+            {
+                return;
+            }
+            if (size <= 0)
+            {
+                size = InitialBufferSize;
+            }
+            if (readChunkSize <= 0)
+            {
+                readChunkSize = ReadBufferSize;
+            }
+            // System.out.println("load "+size+" in chunks of "+readChunkSize);
+            try
+            {
+                // alloc initial buffer size.
+                data = new char[size];
+                // read all the data in chunks of readChunkSize
+                int numRead = 0;
+                int p = 0;
+                do
+                {
+                    if (p + readChunkSize > data.Length)
+                    {
+                        // overflow?
+                        // System.out.println("### overflow p="+p+", data.length="+data.length);
+                        data = Arrays.CopyOf(data, data.Length * 2);
+                    }
+                    numRead = r.Read(data, p, readChunkSize);
+                    // System.out.println("read "+numRead+" chars; p was "+p+" is now "+(p+numRead));
+                    p += numRead;
+                }
+                while (numRead != -1);
+                // while not EOF
+                // set the actual size of the data available;
+                // EOF subtracted one above in p+=numRead; add one back
+                n = p + 1;
+            }
+            finally
+            {
+                //System.out.println("n="+n);
+                r.Close();
+            }
+        }
 
-		/// <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;
-		}
+        /// <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) == IIntStream.Eof);
-				throw new InvalidOperationException("cannot consume EOF");
-			}
-			//System.out.println("prev p="+p+", c="+(char)data[p]);
-			if (p < n)
-			{
-				p++;
-			}
-		}
+        public virtual void Consume()
+        {
+            if (p >= n)
+            {
+                System.Diagnostics.Debug.Assert(La(1) == IIntStream.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 IIntStream.Eof;
-				}
-			}
-			// invalid; no char before first char
-			if ((p + i - 1) >= n)
-			{
-				//System.out.println("char LA("+i+")=EOF; p="+p);
-				return IIntStream.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];
-		}
+        //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 IIntStream.Eof;
+                }
+            }
+            // invalid; no char before first char
+            if ((p + i - 1) >= n)
+            {
+                //System.out.println("char LA("+i+")=EOF; p="+p);
+                return IIntStream.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);
-		}
+        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;
-			}
-		}
+        /// <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;
-			}
-		}
+        public virtual int Size
+        {
+            get
+            {
+                return n;
+            }
+        }
 
-		/// <summary>mark/release do nothing; we have entire buffer</summary>
-		public virtual int Mark()
-		{
-			return -1;
-		}
+        /// <summary>mark/release do nothing; we have entire buffer</summary>
+        public virtual int Mark()
+        {
+            return -1;
+        }
 
-		public virtual void Release(int marker)
-		{
-		}
+        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
-			while (p < index && index < n)
-			{
-				Consume();
-			}
-		}
+        /// <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
+            while (p < index && index < n)
+            {
+                Consume();
+            }
+        }
 
-		public override 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 override 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
-			{
-				return name;
-			}
-		}
+        public virtual string SourceName
+        {
+            get
+            {
+                return name;
+            }
+        }
 
-		public override string ToString()
-		{
-			return new string(data);
-		}
-	}
+        public override string ToString()
+        {
+            return new string(data);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ATN.cs b/Antlr4.Runtime/Atn/ATN.cs
index 7c23fe57f..f3c1cd117 100644
--- a/Antlr4.Runtime/Atn/ATN.cs
+++ b/Antlr4.Runtime/Atn/ATN.cs
@@ -35,189 +35,189 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public class ATN
-	{
-		public const int InvalidAltNumber = 0;
+    public class ATN
+    {
+        public const int InvalidAltNumber = 0;
 
-		public const int Parser = 1;
+        public const int Parser = 1;
 
-		public const int Lexer = 2;
+        public const int Lexer = 2;
 
-		[NotNull]
-		public readonly IList<ATNState> states = new List<ATNState>();
+        [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>
+        /// 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>();
 
-		public RuleStartState[] ruleToStartState;
+        public RuleStartState[] ruleToStartState;
 
-		public RuleStopState[] ruleToStopState;
+        public RuleStopState[] ruleToStopState;
 
-		[NotNull]
-		public readonly IDictionary<string, TokensStartState> modeNameToStartState = new 
-			LinkedHashMap<string, TokensStartState>();
+        [NotNull]
+        public readonly IDictionary<string, TokensStartState> modeNameToStartState = new 
+            LinkedHashMap<string, TokensStartState>();
 
-		public int grammarType;
+        public int grammarType;
 
-		public int maxTokenType;
+        public int maxTokenType;
 
-		public int[] ruleToTokenType;
+        public int[] ruleToTokenType;
 
-		public int[] ruleToActionIndex;
+        public int[] ruleToActionIndex;
 
-		[NotNull]
-		public readonly IList<TokensStartState> modeToStartState = new List<TokensStartState
-			>();
+        [NotNull]
+        public readonly IList<TokensStartState> modeToStartState = new List<TokensStartState
+            >();
 
-		/// <summary>used during construction from grammar AST</summary>
-		internal int stateNumber = 0;
+        /// <summary>used during construction from grammar AST</summary>
+        internal int stateNumber = 0;
 
-		private readonly IConcurrentMap<PredictionContext, PredictionContext> contextCache
-			 = new ConcurrentHashMap<PredictionContext, PredictionContext>();
+        private readonly IConcurrentMap<PredictionContext, PredictionContext> contextCache
+             = new ConcurrentHashMap<PredictionContext, PredictionContext>();
 
-		[NotNull]
-		public DFA[] decisionToDFA = new DFA[0];
+        [NotNull]
+        public DFA[] decisionToDFA = new DFA[0];
 
-		[NotNull]
-		public DFA[] modeToDFA = new DFA[0];
+        [NotNull]
+        public DFA[] modeToDFA = new DFA[0];
 
-		protected internal readonly IConcurrentMap<int, int> LL1Table = new ConcurrentHashMap
-			<int, int>();
+        protected internal readonly IConcurrentMap<int, int> LL1Table = new ConcurrentHashMap
+            <int, int>();
 
-		/// <summary>Used for runtime deserialization of ATNs from strings</summary>
-		public ATN()
-		{
-		}
+        /// <summary>Used for runtime deserialization of ATNs from strings</summary>
+        public ATN()
+        {
+        }
 
-		// runtime for parsers, lexers
-		// ATN.LEXER, ...
-		// runtime for lexer only
-		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();
-		}
+        // runtime for parsers, lexers
+        // ATN.LEXER, ...
+        // runtime for lexer only
+        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 GetContextCacheSize()
-		{
-			return contextCache.Count;
-		}
+        public virtual int GetContextCacheSize()
+        {
+            return contextCache.Count;
+        }
 
-		public virtual PredictionContext GetCachedContext(PredictionContext context)
-		{
-			return PredictionContext.GetCachedContext(context, contextCache, new PredictionContext.IdentityHashMap
-				());
-		}
+        public virtual PredictionContext GetCachedContext(PredictionContext context)
+        {
+            return PredictionContext.GetCachedContext(context, contextCache, new PredictionContext.IdentityHashMap
+                ());
+        }
 
-		public DFA[] GetDecisionToDFA()
-		{
-			System.Diagnostics.Debug.Assert(decisionToDFA != null && decisionToDFA.Length == 
-				decisionToState.Count);
-			return decisionToDFA;
-		}
+        public DFA[] GetDecisionToDFA()
+        {
+            System.Diagnostics.Debug.Assert(decisionToDFA != null && decisionToDFA.Length == 
+                decisionToState.Count);
+            return decisionToDFA;
+        }
 
-		/// <summary>Compute the set of valid tokens that can occur starting in s.</summary>
-		/// <remarks>
-		/// Compute the set of valid tokens that can occur starting in s.
-		/// If ctx is
-		/// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
-		/// , the set of tokens will not include what can follow
-		/// the rule surrounding s. In other words, the set will be
-		/// restricted to tokens reachable staying within s's rule.
-		/// </remarks>
-		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 s.</summary>
+        /// <remarks>
+        /// Compute the set of valid tokens that can occur starting in s.
+        /// If ctx is
+        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// , the set of tokens will not include what can follow
+        /// the rule surrounding s. In other words, the set will be
+        /// restricted to tokens reachable staying within s's rule.
+        /// </remarks>
+        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 s and staying in same rule.
-		/// 	</summary>
-		/// <remarks>
-		/// Compute the set of valid tokens that can occur starting in s and staying in same rule.
-		/// EPSILON is in set if we reach end of rule.
-		/// </remarks>
-		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;
-		}
+        /// <summary>Compute the set of valid tokens that can occur starting in s and staying in same rule.
+        ///     </summary>
+        /// <remarks>
+        /// Compute the set of valid tokens that can occur starting in s and staying in same rule.
+        /// EPSILON is in set if we reach end of rule.
+        /// </remarks>
+        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)
-			{
-				states.AddItem(null);
-				stateNumber++;
-				return;
-			}
-			state.atn = this;
-			states.AddItem(state);
-			state.stateNumber = stateNumber++;
-		}
+        public virtual void AddState(ATNState state)
+        {
+            if (state == null)
+            {
+                states.AddItem(null);
+                stateNumber++;
+                return;
+            }
+            state.atn = this;
+            states.AddItem(state);
+            state.stateNumber = stateNumber++;
+        }
 
-		public virtual void RemoveState(ATNState state)
-		{
-			states.Set(state.stateNumber, null);
-		}
+        public virtual void RemoveState(ATNState state)
+        {
+            states.Set(state.stateNumber, null);
+        }
 
-		// just free mem, don't shift states in list
-		public virtual void DefineMode(string name, TokensStartState s)
-		{
-			modeNameToStartState.Put(name, s);
-			modeToStartState.AddItem(s);
-			modeToDFA = Arrays.CopyOf(modeToDFA, modeToStartState.Count);
-			modeToDFA[modeToDFA.Length - 1] = new DFA(s);
-			DefineDecisionState(s);
-		}
+        // just free mem, don't shift states in list
+        public virtual void DefineMode(string name, TokensStartState s)
+        {
+            modeNameToStartState.Put(name, s);
+            modeToStartState.AddItem(s);
+            modeToDFA = Arrays.CopyOf(modeToDFA, modeToStartState.Count);
+            modeToDFA[modeToDFA.Length - 1] = new DFA(s);
+            DefineDecisionState(s);
+        }
 
-		public virtual int DefineDecisionState(DecisionState s)
-		{
-			decisionToState.AddItem(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 int DefineDecisionState(DecisionState s)
+        {
+            decisionToState.AddItem(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.IsEmpty())
-			{
-				return decisionToState[decision];
-			}
-			return null;
-		}
+        public virtual DecisionState GetDecisionState(int decision)
+        {
+            if (!decisionToState.IsEmpty())
+            {
+                return decisionToState[decision];
+            }
+            return null;
+        }
 
-		public virtual int GetNumberOfDecisions()
-		{
-			return decisionToState.Count;
-		}
-	}
+        public virtual int GetNumberOfDecisions()
+        {
+            return decisionToState.Count;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ATNConfig.cs b/Antlr4.Runtime/Atn/ATNConfig.cs
index 8b7d99638..554ea2ff5 100644
--- a/Antlr4.Runtime/Atn/ATNConfig.cs
+++ b/Antlr4.Runtime/Atn/ATNConfig.cs
@@ -37,515 +37,515 @@ using 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>The ATN state associated with this configuration</summary>
-		[NotNull]
-		private readonly ATNState state;
+    /// <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>The ATN state associated with this configuration</summary>
+        [NotNull]
+        private readonly ATNState state;
 
-		private int altAndOuterContextDepth;
+        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;
+        /// <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 & unchecked((int)(0x7FFFFFFF));
-			this.context = 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 & unchecked((int)(0x7FFFFFFF));
+            this.context = context;
+        }
 
-		protected internal ATNConfig(Antlr4.Runtime.Atn.ATNConfig c, ATNState state, PredictionContext
-			 context)
-		{
-			this.state = state;
-			this.altAndOuterContextDepth = c.altAndOuterContextDepth & unchecked((int)(0x7FFFFFFF
-				));
-			this.context = context;
-		}
+        protected internal ATNConfig(Antlr4.Runtime.Atn.ATNConfig c, ATNState state, PredictionContext
+             context)
+        {
+            this.state = state;
+            this.altAndOuterContextDepth = c.altAndOuterContextDepth & unchecked((int)(0x7FFFFFFF
+                ));
+            this.context = context;
+        }
 
-		public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
-			 context)
-		{
-			return Create(state, alt, context, SemanticContext.None, -1);
-		}
+        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
+             context)
+        {
+            return Create(state, alt, context, SemanticContext.None, -1);
+        }
 
-		public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
-			 context, SemanticContext semanticContext)
-		{
-			return Create(state, alt, context, semanticContext, -1);
-		}
+        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
+             context, SemanticContext semanticContext)
+        {
+            return Create(state, alt, context, semanticContext, -1);
+        }
 
-		public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
-			 context, SemanticContext semanticContext, int actionIndex)
-		{
-			if (semanticContext != SemanticContext.None)
-			{
-				if (actionIndex != -1)
-				{
-					return new ATNConfig.ActionSemanticContextATNConfig(actionIndex, semanticContext, 
-						state, alt, context);
-				}
-				else
-				{
-					return new ATNConfig.SemanticContextATNConfig(semanticContext, state, alt, context
-						);
-				}
-			}
-			else
-			{
-				if (actionIndex != -1)
-				{
-					return new ATNConfig.ActionATNConfig(actionIndex, state, alt, context);
-				}
-				else
-				{
-					return new Antlr4.Runtime.Atn.ATNConfig(state, alt, context);
-				}
-			}
-		}
+        public static Antlr4.Runtime.Atn.ATNConfig Create(ATNState state, int alt, PredictionContext
+             context, SemanticContext semanticContext, int actionIndex)
+        {
+            if (semanticContext != SemanticContext.None)
+            {
+                if (actionIndex != -1)
+                {
+                    return new ATNConfig.ActionSemanticContextATNConfig(actionIndex, semanticContext, 
+                        state, alt, context);
+                }
+                else
+                {
+                    return new ATNConfig.SemanticContextATNConfig(semanticContext, state, alt, context
+                        );
+                }
+            }
+            else
+            {
+                if (actionIndex != -1)
+                {
+                    return new ATNConfig.ActionATNConfig(actionIndex, state, alt, context);
+                }
+                else
+                {
+                    return new Antlr4.Runtime.Atn.ATNConfig(state, alt, context);
+                }
+            }
+        }
 
-		/// <summary>Gets the ATN state associated with this configuration</summary>
-		[NotNull]
-		public ATNState GetState()
-		{
-			return state;
-		}
+        /// <summary>Gets the ATN state associated with this configuration</summary>
+        [NotNull]
+        public ATNState GetState()
+        {
+            return state;
+        }
 
-		/// <summary>What alt (or lexer rule) is predicted by this configuration</summary>
-		public int GetAlt()
-		{
-			return altAndOuterContextDepth & unchecked((int)(0x00FFFFFF));
-		}
+        /// <summary>What alt (or lexer rule) is predicted by this configuration</summary>
+        public int GetAlt()
+        {
+            return altAndOuterContextDepth & unchecked((int)(0x00FFFFFF));
+        }
 
-		public bool IsHidden()
-		{
-			return altAndOuterContextDepth < 0;
-		}
+        public bool IsHidden()
+        {
+            return altAndOuterContextDepth < 0;
+        }
 
-		public virtual void SetHidden(bool value)
-		{
-			if (value)
-			{
-				altAndOuterContextDepth |= unchecked((int)(0x80000000));
-			}
-			else
-			{
-				altAndOuterContextDepth &= ~unchecked((int)(0x80000000));
-			}
-		}
+        public virtual void SetHidden(bool value)
+        {
+            if (value)
+            {
+                altAndOuterContextDepth |= unchecked((int)(0x80000000));
+            }
+            else
+            {
+                altAndOuterContextDepth &= ~unchecked((int)(0x80000000));
+            }
+        }
 
-		[NotNull]
-		public PredictionContext GetContext()
-		{
-			return context;
-		}
+        [NotNull]
+        public PredictionContext GetContext()
+        {
+            return context;
+        }
 
-		public virtual void SetContext(PredictionContext context)
-		{
-			this.context = context;
-		}
+        public virtual void SetContext(PredictionContext context)
+        {
+            this.context = context;
+        }
 
-		public bool GetReachesIntoOuterContext()
-		{
-			return GetOuterContextDepth() != 0;
-		}
+        public bool GetReachesIntoOuterContext()
+        {
+            return GetOuterContextDepth() != 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.
-		/// 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
-		/// </remarks>
-		public int GetOuterContextDepth()
-		{
-			return ((int)(((uint)altAndOuterContextDepth) >> 24)) & unchecked((int)(0x7F));
-		}
+        /// <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.
+        /// 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
+        /// </remarks>
+        public int GetOuterContextDepth()
+        {
+            return ((int)(((uint)altAndOuterContextDepth) >> 24)) & unchecked((int)(0x7F));
+        }
 
-		public virtual void SetOuterContextDepth(int outerContextDepth)
-		{
-			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 void SetOuterContextDepth(int outerContextDepth)
+        {
+            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 int GetActionIndex()
-		{
-			return -1;
-		}
+        public virtual int GetActionIndex()
+        {
+            return -1;
+        }
 
-		[NotNull]
-		public virtual SemanticContext GetSemanticContext()
-		{
-			return SemanticContext.None;
-		}
+        [NotNull]
+        public virtual SemanticContext GetSemanticContext()
+        {
+            return SemanticContext.None;
+        }
 
-		public Antlr4.Runtime.Atn.ATNConfig Clone()
-		{
-			return Transform(this.GetState());
-		}
+        public Antlr4.Runtime.Atn.ATNConfig Clone()
+        {
+            return Transform(this.GetState());
+        }
 
-		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state)
-		{
-			return Transform(state, this.context, this.GetSemanticContext(), this.GetActionIndex
-				());
-		}
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state)
+        {
+            return Transform(state, this.context, this.GetSemanticContext(), this.GetActionIndex
+                ());
+        }
 
-		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, SemanticContext semanticContext
-			)
-		{
-			return Transform(state, this.context, semanticContext, this.GetActionIndex());
-		}
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, SemanticContext semanticContext
+            )
+        {
+            return Transform(state, this.context, semanticContext, this.GetActionIndex());
+        }
 
-		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context
-			)
-		{
-			return Transform(state, context, this.GetSemanticContext(), this.GetActionIndex()
-				);
-		}
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext context
+            )
+        {
+            return Transform(state, context, this.GetSemanticContext(), this.GetActionIndex()
+                );
+        }
 
-		public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, int actionIndex)
-		{
-			return Transform(state, context, this.GetSemanticContext(), actionIndex);
-		}
+        public Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, int actionIndex)
+        {
+            return Transform(state, context, this.GetSemanticContext(), actionIndex);
+        }
 
-		private Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext 
-			context, SemanticContext semanticContext, int actionIndex)
-		{
-			if (semanticContext != SemanticContext.None)
-			{
-				if (actionIndex != -1)
-				{
-					return new ATNConfig.ActionSemanticContextATNConfig(actionIndex, semanticContext, 
-						this, state, context);
-				}
-				else
-				{
-					return new ATNConfig.SemanticContextATNConfig(semanticContext, this, state, context
-						);
-				}
-			}
-			else
-			{
-				if (actionIndex != -1)
-				{
-					return new ATNConfig.ActionATNConfig(actionIndex, this, state, context);
-				}
-				else
-				{
-					return new Antlr4.Runtime.Atn.ATNConfig(this, state, context);
-				}
-			}
-		}
+        private Antlr4.Runtime.Atn.ATNConfig Transform(ATNState state, PredictionContext 
+            context, SemanticContext semanticContext, int actionIndex)
+        {
+            if (semanticContext != SemanticContext.None)
+            {
+                if (actionIndex != -1)
+                {
+                    return new ATNConfig.ActionSemanticContextATNConfig(actionIndex, semanticContext, 
+                        this, state, context);
+                }
+                else
+                {
+                    return new ATNConfig.SemanticContextATNConfig(semanticContext, this, state, context
+                        );
+                }
+            }
+            else
+            {
+                if (actionIndex != -1)
+                {
+                    return new ATNConfig.ActionATNConfig(actionIndex, this, state, context);
+                }
+                else
+                {
+                    return new Antlr4.Runtime.Atn.ATNConfig(this, state, context);
+                }
+            }
+        }
 
-		public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(int context, PredictionContextCache
-			 contextCache)
-		{
-			PredictionContext appendedContext = GetContext().AppendContext(context, contextCache
-				);
-			Antlr4.Runtime.Atn.ATNConfig result = Transform(GetState(), appendedContext);
-			return result;
-		}
+        public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(int context, PredictionContextCache
+             contextCache)
+        {
+            PredictionContext appendedContext = GetContext().AppendContext(context, contextCache
+                );
+            Antlr4.Runtime.Atn.ATNConfig result = Transform(GetState(), appendedContext);
+            return result;
+        }
 
-		public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(PredictionContext context
-			, PredictionContextCache contextCache)
-		{
-			PredictionContext appendedContext = GetContext().AppendContext(context, contextCache
-				);
-			Antlr4.Runtime.Atn.ATNConfig result = Transform(GetState(), appendedContext);
-			return result;
-		}
+        public virtual Antlr4.Runtime.Atn.ATNConfig AppendContext(PredictionContext context
+            , PredictionContextCache contextCache)
+        {
+            PredictionContext appendedContext = GetContext().AppendContext(context, contextCache
+                );
+            Antlr4.Runtime.Atn.ATNConfig result = Transform(GetState(), appendedContext);
+            return result;
+        }
 
-		public virtual bool Contains(Antlr4.Runtime.Atn.ATNConfig subconfig)
-		{
-			if (this.GetState().stateNumber != subconfig.GetState().stateNumber || this.GetAlt
-				() != subconfig.GetAlt() || !this.GetSemanticContext().Equals(subconfig.GetSemanticContext
-				()))
-			{
-				return false;
-			}
-			IDeque<PredictionContext> leftWorkList = new ArrayDeque<PredictionContext>();
-			IDeque<PredictionContext> rightWorkList = new ArrayDeque<PredictionContext>();
-			leftWorkList.AddItem(GetContext());
-			rightWorkList.AddItem(subconfig.GetContext());
-			while (!leftWorkList.IsEmpty())
-			{
-				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 virtual bool Contains(Antlr4.Runtime.Atn.ATNConfig subconfig)
+        {
+            if (this.GetState().stateNumber != subconfig.GetState().stateNumber || this.GetAlt
+                () != subconfig.GetAlt() || !this.GetSemanticContext().Equals(subconfig.GetSemanticContext
+                ()))
+            {
+                return false;
+            }
+            IDeque<PredictionContext> leftWorkList = new ArrayDeque<PredictionContext>();
+            IDeque<PredictionContext> rightWorkList = new ArrayDeque<PredictionContext>();
+            leftWorkList.AddItem(GetContext());
+            rightWorkList.AddItem(subconfig.GetContext());
+            while (!leftWorkList.IsEmpty())
+            {
+                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;
+        }
 
-		/// <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);
-		}
+        /// <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.GetState().stateNumber == other.GetState().stateNumber && this.GetAlt
-				() == other.GetAlt() && this.GetReachesIntoOuterContext() == other.GetReachesIntoOuterContext
-				() && this.GetContext().Equals(other.GetContext()) && this.GetSemanticContext().
-				Equals(other.GetSemanticContext()) && this.GetActionIndex() == other.GetActionIndex
-				();
-		}
+        public virtual bool Equals(Antlr4.Runtime.Atn.ATNConfig other)
+        {
+            if (this == other)
+            {
+                return true;
+            }
+            else
+            {
+                if (other == null)
+                {
+                    return false;
+                }
+            }
+            return this.GetState().stateNumber == other.GetState().stateNumber && this.GetAlt
+                () == other.GetAlt() && this.GetReachesIntoOuterContext() == other.GetReachesIntoOuterContext
+                () && this.GetContext().Equals(other.GetContext()) && this.GetSemanticContext
+                ().Equals(other.GetSemanticContext()) && this.GetActionIndex() == other.GetActionIndex
+                ();
+        }
 
-		public override int GetHashCode()
-		{
-			int hashCode = 7;
-			hashCode = 5 * hashCode + GetState().stateNumber;
-			hashCode = 5 * hashCode + GetAlt();
-			hashCode = 5 * hashCode + (GetReachesIntoOuterContext() ? 1 : 0);
-			hashCode = 5 * hashCode + (GetContext() != null ? GetContext().GetHashCode() : 0);
-			hashCode = 5 * hashCode + GetSemanticContext().GetHashCode();
-			return hashCode;
-		}
+        public override int GetHashCode()
+        {
+            int hashCode = 7;
+            hashCode = 5 * hashCode + GetState().stateNumber;
+            hashCode = 5 * hashCode + GetAlt();
+            hashCode = 5 * hashCode + (GetReachesIntoOuterContext() ? 1 : 0);
+            hashCode = 5 * hashCode + (GetContext() != null ? GetContext().GetHashCode() : 0);
+            hashCode = 5 * hashCode + GetSemanticContext().GetHashCode();
+            return hashCode;
+        }
 
-		public virtual string ToDotString()
-		{
-			StringBuilder builder = new StringBuilder();
-			builder.Append("digraph G {\n");
-			builder.Append("rankdir=LR;\n");
-			IDictionary<PredictionContext, PredictionContext> visited = new IdentityHashMap<PredictionContext
-				, PredictionContext>();
-			IDeque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
-			workList.AddItem(GetContext());
-			visited.Put(GetContext(), GetContext());
-			while (!workList.IsEmpty())
-			{
-				PredictionContext current = workList.Pop();
-				for (int i = 0; i < current.Size; i++)
-				{
-					builder.Append("  s").Append(Sharpen.Runtime.IdentityHashCode(current));
-					builder.Append("->");
-					builder.Append("s").Append(Sharpen.Runtime.IdentityHashCode(current.GetParent(i))
-						);
-					builder.Append("[label=\"").Append(current.GetReturnState(i)).Append("\"];\n");
-					if (visited.Put(current.GetParent(i), current.GetParent(i)) == null)
-					{
-						workList.Push(current.GetParent(i));
-					}
-				}
-			}
-			builder.Append("}\n");
-			return builder.ToString();
-		}
+        public virtual string ToDotString()
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.Append("digraph G {\n");
+            builder.Append("rankdir=LR;\n");
+            IDictionary<PredictionContext, PredictionContext> visited = new IdentityHashMap<PredictionContext
+                , PredictionContext>();
+            IDeque<PredictionContext> workList = new ArrayDeque<PredictionContext>();
+            workList.AddItem(GetContext());
+            visited.Put(GetContext(), GetContext());
+            while (!workList.IsEmpty())
+            {
+                PredictionContext current = workList.Pop();
+                for (int i = 0; i < current.Size; i++)
+                {
+                    builder.Append("  s").Append(Sharpen.Runtime.IdentityHashCode(current));
+                    builder.Append("->");
+                    builder.Append("s").Append(Sharpen.Runtime.IdentityHashCode(current.GetParent(i))
+                        );
+                    builder.Append("[label=\"").Append(current.GetReturnState(i)).Append("\"];\n");
+                    if (visited.Put(current.GetParent(i), current.GetParent(i)) == null)
+                    {
+                        workList.Push(current.GetParent(i));
+                    }
+                }
+            }
+            builder.Append("}\n");
+            return builder.ToString();
+        }
 
-		public override string ToString()
-		{
-			return ToString(null, true, false);
-		}
+        public override string ToString()
+        {
+            return ToString(null, true, false);
+        }
 
-		public virtual string ToString<_T0>(Recognizer<_T0> recog, bool showAlt)
-		{
-			return ToString(recog, showAlt, true);
-		}
+        public virtual string ToString<_T0>(Recognizer<_T0> recog, bool showAlt)
+        {
+            return ToString(recog, showAlt, true);
+        }
 
-		public virtual string ToString<_T0>(Recognizer<_T0> 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 = GetContext().ToStrings(recog, this.GetState().stateNumber);
-			}
-			else
-			{
-				contexts = new string[] { "?" };
-			}
-			bool first = true;
-			foreach (string contextDesc in contexts)
-			{
-				if (first)
-				{
-					first = false;
-				}
-				else
-				{
-					buf.Append(", ");
-				}
-				buf.Append('(');
-				buf.Append(GetState());
-				if (showAlt)
-				{
-					buf.Append(",");
-					buf.Append(GetAlt());
-				}
-				if (GetContext() != null)
-				{
-					buf.Append(",");
-					buf.Append(contextDesc);
-				}
-				if (GetSemanticContext() != null && GetSemanticContext() != SemanticContext.None)
-				{
-					buf.Append(",");
-					buf.Append(GetSemanticContext());
-				}
-				if (GetReachesIntoOuterContext())
-				{
-					buf.Append(",up=").Append(GetOuterContextDepth());
-				}
-				buf.Append(')');
-			}
-			return buf.ToString();
-		}
+        public virtual string ToString<_T0>(Recognizer<_T0> 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 = GetContext().ToStrings(recog, this.GetState().stateNumber);
+            }
+            else
+            {
+                contexts = new string[] { "?" };
+            }
+            bool first = true;
+            foreach (string contextDesc in contexts)
+            {
+                if (first)
+                {
+                    first = false;
+                }
+                else
+                {
+                    buf.Append(", ");
+                }
+                buf.Append('(');
+                buf.Append(GetState());
+                if (showAlt)
+                {
+                    buf.Append(",");
+                    buf.Append(GetAlt());
+                }
+                if (GetContext() != null)
+                {
+                    buf.Append(",");
+                    buf.Append(contextDesc);
+                }
+                if (GetSemanticContext() != null && GetSemanticContext() != SemanticContext.None)
+                {
+                    buf.Append(",");
+                    buf.Append(GetSemanticContext());
+                }
+                if (GetReachesIntoOuterContext())
+                {
+                    buf.Append(",up=").Append(GetOuterContextDepth());
+                }
+                buf.Append(')');
+            }
+            return buf.ToString();
+        }
 
-		private class SemanticContextATNConfig : ATNConfig
-		{
-			[NotNull]
-			private readonly SemanticContext semanticContext;
+        private class SemanticContextATNConfig : ATNConfig
+        {
+            [NotNull]
+            private readonly SemanticContext semanticContext;
 
-			public SemanticContextATNConfig(SemanticContext semanticContext, ATNState state, 
-				int alt, PredictionContext context) : base(state, alt, context)
-			{
-				this.semanticContext = semanticContext;
-			}
+            public SemanticContextATNConfig(SemanticContext semanticContext, ATNState state, 
+                int alt, PredictionContext context) : base(state, alt, context)
+            {
+                this.semanticContext = semanticContext;
+            }
 
-			public SemanticContextATNConfig(SemanticContext semanticContext, ATNConfig c, ATNState
-				 state, PredictionContext context) : base(c, state, context)
-			{
-				this.semanticContext = semanticContext;
-			}
+            public SemanticContextATNConfig(SemanticContext semanticContext, ATNConfig c, ATNState
+                 state, PredictionContext context) : base(c, state, context)
+            {
+                this.semanticContext = semanticContext;
+            }
 
-			public override SemanticContext GetSemanticContext()
-			{
-				return semanticContext;
-			}
-		}
+            public override SemanticContext GetSemanticContext()
+            {
+                return semanticContext;
+            }
+        }
 
-		private class ActionATNConfig : ATNConfig
-		{
-			private readonly int actionIndex;
+        private class ActionATNConfig : ATNConfig
+        {
+            private readonly int actionIndex;
 
-			public ActionATNConfig(int actionIndex, ATNState state, int alt, PredictionContext
-				 context) : base(state, alt, context)
-			{
-				this.actionIndex = actionIndex;
-			}
+            public ActionATNConfig(int actionIndex, ATNState state, int alt, PredictionContext
+                 context) : base(state, alt, context)
+            {
+                this.actionIndex = actionIndex;
+            }
 
-			protected internal ActionATNConfig(int actionIndex, ATNConfig c, ATNState state, 
-				PredictionContext context) : base(c, state, context)
-			{
-				if (c.GetSemanticContext() != SemanticContext.None)
-				{
-					throw new NotSupportedException();
-				}
-				this.actionIndex = actionIndex;
-			}
+            protected internal ActionATNConfig(int actionIndex, ATNConfig c, ATNState state, 
+                PredictionContext context) : base(c, state, context)
+            {
+                if (c.GetSemanticContext() != SemanticContext.None)
+                {
+                    throw new NotSupportedException();
+                }
+                this.actionIndex = actionIndex;
+            }
 
-			public override int GetActionIndex()
-			{
-				return actionIndex;
-			}
-		}
+            public override int GetActionIndex()
+            {
+                return actionIndex;
+            }
+        }
 
-		private class ActionSemanticContextATNConfig : ATNConfig.SemanticContextATNConfig
-		{
-			private readonly int actionIndex;
+        private class ActionSemanticContextATNConfig : ATNConfig.SemanticContextATNConfig
+        {
+            private readonly int actionIndex;
 
-			public ActionSemanticContextATNConfig(int actionIndex, SemanticContext semanticContext
-				, ATNState state, int alt, PredictionContext context) : base(semanticContext, state
-				, alt, context)
-			{
-				this.actionIndex = actionIndex;
-			}
+            public ActionSemanticContextATNConfig(int actionIndex, SemanticContext semanticContext
+                , ATNState state, int alt, PredictionContext context) : base(semanticContext, 
+                state, alt, context)
+            {
+                this.actionIndex = actionIndex;
+            }
 
-			public ActionSemanticContextATNConfig(int actionIndex, SemanticContext semanticContext
-				, ATNConfig c, ATNState state, PredictionContext context) : base(semanticContext
-				, c, state, context)
-			{
-				this.actionIndex = actionIndex;
-			}
+            public ActionSemanticContextATNConfig(int actionIndex, SemanticContext semanticContext
+                , ATNConfig c, ATNState state, PredictionContext context) : base(semanticContext
+                , c, state, context)
+            {
+                this.actionIndex = actionIndex;
+            }
 
-			public override int GetActionIndex()
-			{
-				return actionIndex;
-			}
-		}
-	}
+            public override int GetActionIndex()
+            {
+                return actionIndex;
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ATNConfigSet.cs b/Antlr4.Runtime/Atn/ATNConfigSet.cs
index bb38eeb25..16bd91df8 100644
--- a/Antlr4.Runtime/Atn/ATNConfigSet.cs
+++ b/Antlr4.Runtime/Atn/ATNConfigSet.cs
@@ -36,657 +36,657 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public class ATNConfigSet : ICollection<ATNConfig>
-	{
-		/// <summary>
-		/// This maps (state, alt) -&gt; merged
-		/// <see cref="ATNConfig">ATNConfig</see>
-		/// . The key does not account for
-		/// the
-		/// <see cref="ATNConfig.GetSemanticContext()">ATNConfig.GetSemanticContext()</see>
-		/// of the value, which is only a problem if a single
-		/// <code>ATNConfigSet</code>
-		/// 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">unmerged</see>
-		/// .
-		/// <p>
-		/// This map is only used for optimizing the process of adding configs to the set,
-		/// and is
-		/// <code>null</code>
-		/// for read-only sets stored in the DFA.
-		/// </summary>
-		private readonly Dictionary<long, ATNConfig> mergedConfigs;
+    /// <author>Sam Harwell</author>
+    public class ATNConfigSet : ICollection<ATNConfig>
+    {
+        /// <summary>
+        /// This maps (state, alt) -&gt; merged
+        /// <see cref="ATNConfig">ATNConfig</see>
+        /// . The key does not account for
+        /// the
+        /// <see cref="ATNConfig.GetSemanticContext()">ATNConfig.GetSemanticContext()</see>
+        /// of the value, which is only a problem if a single
+        /// <code>ATNConfigSet</code>
+        /// 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">unmerged</see>
+        /// .
+        /// <p>
+        /// This map is only used for optimizing the process of adding configs to the set,
+        /// and is
+        /// <code>null</code>
+        /// 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">mergedConfigs</see>
-		/// 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
-		/// <code>null</code>
-		/// for read-only sets stored in the DFA.
-		/// </summary>
-		private readonly List<ATNConfig> unmerged;
+        /// <summary>
+        /// This is an "overflow" list holding configs which cannot be merged with one
+        /// of the configs in
+        /// <see cref="mergedConfigs">mergedConfigs</see>
+        /// 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
+        /// <code>null</code>
+        /// 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;
+        /// <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 int uniqueAlt;
 
-		private BitSet conflictingAlts;
+        private BitSet conflictingAlts;
 
-		private bool hasSemanticContext;
+        private bool hasSemanticContext;
 
-		private bool dipsIntoOuterContext;
+        private bool dipsIntoOuterContext;
 
-		/// <summary>
-		/// When
-		/// <code>true</code>
-		/// , 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)
-		/// 	">ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache)
-		/// 	</see>
-		/// from pursuing the global FOLLOW when a
-		/// rule stop state is reached with an empty prediction context.
-		/// <p>
-		/// Note:
-		/// <code>outermostConfigSet</code>
-		/// and
-		/// <see cref="dipsIntoOuterContext">dipsIntoOuterContext</see>
-		/// should never
-		/// be true at the same time.
-		/// </summary>
-		private bool outermostConfigSet;
+        /// <summary>
+        /// When
+        /// <code>true</code>
+        /// , 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)
+        ///     ">ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache)
+        ///     </see>
+        /// from pursuing the global FOLLOW when a
+        /// rule stop state is reached with an empty prediction context.
+        /// <p>
+        /// Note:
+        /// <code>outermostConfigSet</code>
+        /// and
+        /// <see cref="dipsIntoOuterContext">dipsIntoOuterContext</see>
+        /// should never
+        /// be true at the same time.
+        /// </summary>
+        private bool outermostConfigSet;
 
-		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;
-		}
+        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 = (Dictionary<long, ATNConfig>)set.mergedConfigs.Clone();
-					this.unmerged = (List<ATNConfig>)set.unmerged.Clone();
-				}
-				else
-				{
-					this.mergedConfigs = new Dictionary<long, ATNConfig>(set.configs.Count);
-					this.unmerged = new List<ATNConfig>();
-				}
-			}
-			this.configs = (List<ATNConfig>)set.configs.Clone();
-			this.dipsIntoOuterContext = set.dipsIntoOuterContext;
-			this.hasSemanticContext = set.hasSemanticContext;
-			this.outermostConfigSet = set.outermostConfigSet;
-			if (@readonly || !set.IsReadOnly())
-			{
-				this.uniqueAlt = set.uniqueAlt;
-				this.conflictingAlts = set.conflictingAlts;
-			}
-		}
+        protected internal ATNConfigSet(Antlr4.Runtime.Atn.ATNConfigSet set, bool @readonly
+            )
+        {
+            if (@readonly)
+            {
+                this.mergedConfigs = null;
+                this.unmerged = null;
+            }
+            else
+            {
+                if (!set.IsReadOnly())
+                {
+                    this.mergedConfigs = (Dictionary<long, ATNConfig>)set.mergedConfigs.Clone();
+                    this.unmerged = (List<ATNConfig>)set.unmerged.Clone();
+                }
+                else
+                {
+                    this.mergedConfigs = new Dictionary<long, ATNConfig>(set.configs.Count);
+                    this.unmerged = new List<ATNConfig>();
+                }
+            }
+            this.configs = (List<ATNConfig>)set.configs.Clone();
+            this.dipsIntoOuterContext = set.dipsIntoOuterContext;
+            this.hasSemanticContext = set.hasSemanticContext;
+            this.outermostConfigSet = set.outermostConfigSet;
+            if (@readonly || !set.IsReadOnly())
+            {
+                this.uniqueAlt = set.uniqueAlt;
+                this.conflictingAlts = set.conflictingAlts;
+            }
+        }
 
-		// if (!readonly && set.isReadOnly()) -> addAll is called from clone()
-		/// <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 GetRepresentedAlternatives()
-		{
-			if (conflictingAlts != null)
-			{
-				return (BitSet)conflictingAlts.Clone();
-			}
-			BitSet alts = new BitSet();
-			foreach (ATNConfig config in this)
-			{
-				alts.Set(config.GetAlt());
-			}
-			return alts;
-		}
+        // if (!readonly && set.isReadOnly()) -> addAll is called from clone()
+        /// <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 GetRepresentedAlternatives()
+        {
+            if (conflictingAlts != null)
+            {
+                return (BitSet)conflictingAlts.Clone();
+            }
+            BitSet alts = new BitSet();
+            foreach (ATNConfig config in this)
+            {
+                alts.Set(config.GetAlt());
+            }
+            return alts;
+        }
 
-		public bool IsReadOnly()
-		{
-			return mergedConfigs == null;
-		}
+        public bool IsReadOnly()
+        {
+            return mergedConfigs == null;
+        }
 
-		public void StripHiddenConfigs()
-		{
-			EnsureWritable();
-			IEnumerator<KeyValuePair<long, ATNConfig>> iterator = mergedConfigs.EntrySet().GetEnumerator
-				();
-			while (iterator.HasNext())
-			{
-				if (iterator.Next().Value.IsHidden())
-				{
-					iterator.Remove();
-				}
-			}
-			IListIterator<ATNConfig> iterator2 = unmerged.ListIterator();
-			while (iterator2.HasNext())
-			{
-				if (iterator2.Next().IsHidden())
-				{
-					iterator2.Remove();
-				}
-			}
-			iterator2 = configs.ListIterator();
-			while (iterator2.HasNext())
-			{
-				if (iterator2.Next().IsHidden())
-				{
-					iterator2.Remove();
-				}
-			}
-		}
+        public void StripHiddenConfigs()
+        {
+            EnsureWritable();
+            IEnumerator<KeyValuePair<long, ATNConfig>> iterator = mergedConfigs.EntrySet().GetEnumerator
+                ();
+            while (iterator.HasNext())
+            {
+                if (iterator.Next().Value.IsHidden())
+                {
+                    iterator.Remove();
+                }
+            }
+            IListIterator<ATNConfig> iterator2 = unmerged.ListIterator();
+            while (iterator2.HasNext())
+            {
+                if (iterator2.Next().IsHidden())
+                {
+                    iterator2.Remove();
+                }
+            }
+            iterator2 = configs.ListIterator();
+            while (iterator2.HasNext())
+            {
+                if (iterator2.Next().IsHidden())
+                {
+                    iterator2.Remove();
+                }
+            }
+        }
 
-		public virtual bool IsOutermostConfigSet()
-		{
-			return outermostConfigSet;
-		}
+        public virtual bool IsOutermostConfigSet()
+        {
+            return outermostConfigSet;
+        }
 
-		public virtual void SetOutermostConfigSet(bool outermostConfigSet)
-		{
-			if (this.outermostConfigSet && !outermostConfigSet)
-			{
-				throw new InvalidOperationException();
-			}
-			System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
-			this.outermostConfigSet = outermostConfigSet;
-		}
+        public virtual void SetOutermostConfigSet(bool outermostConfigSet)
+        {
+            if (this.outermostConfigSet && !outermostConfigSet)
+            {
+                throw new InvalidOperationException();
+            }
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+            this.outermostConfigSet = outermostConfigSet;
+        }
 
-		public virtual ICollection<ATNState> GetStates()
-		{
-			ICollection<ATNState> states = new HashSet<ATNState>();
-			foreach (ATNConfig c in this.configs)
-			{
-				states.AddItem(c.GetState());
-			}
-			return states;
-		}
+        public virtual ICollection<ATNState> GetStates()
+        {
+            ICollection<ATNState> states = new HashSet<ATNState>();
+            foreach (ATNConfig c in this.configs)
+            {
+                states.AddItem(c.GetState());
+            }
+            return states;
+        }
 
-		public virtual void OptimizeConfigs(ATNSimulator interpreter)
-		{
-			if (configs.IsEmpty())
-			{
-				return;
-			}
-			for (int i = 0; i < configs.Count; i++)
-			{
-				ATNConfig config = configs[i];
-				config.SetContext(interpreter.atn.GetCachedContext(config.GetContext()));
-			}
-		}
+        public virtual void OptimizeConfigs(ATNSimulator interpreter)
+        {
+            if (configs.IsEmpty())
+            {
+                return;
+            }
+            for (int i = 0; i < configs.Count; i++)
+            {
+                ATNConfig config = configs[i];
+                config.SetContext(interpreter.atn.GetCachedContext(config.GetContext()));
+            }
+        }
 
-		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())
-			{
-				Sharpen.Collections.AddAll(copy, this.configs);
-			}
-			return copy;
-		}
+        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())
+            {
+                Sharpen.Collections.AddAll(copy, this.configs);
+            }
+            return copy;
+        }
 
-		public virtual int Count
-		{
-			get
-			{
-				return configs.Count;
-			}
-		}
+        public virtual int Count
+        {
+            get
+            {
+                return configs.Count;
+            }
+        }
 
-		public virtual bool IsEmpty()
-		{
-			return configs.IsEmpty();
-		}
+        public virtual bool IsEmpty()
+        {
+            return configs.IsEmpty();
+        }
 
-		public virtual bool Contains(object o)
-		{
-			if (!(o is ATNConfig))
-			{
-				return false;
-			}
-			ATNConfig config = (ATNConfig)o;
-			long configKey = GetKey(config);
-			ATNConfig mergedConfig = mergedConfigs.Get(configKey);
-			if (mergedConfig != null && CanMerge(config, configKey, mergedConfig))
-			{
-				return mergedConfig.Contains(config);
-			}
-			foreach (ATNConfig c in unmerged)
-			{
-				if (c.Contains(config))
-				{
-					return true;
-				}
-			}
-			return false;
-		}
+        public virtual bool Contains(object o)
+        {
+            if (!(o is ATNConfig))
+            {
+                return false;
+            }
+            ATNConfig config = (ATNConfig)o;
+            long configKey = GetKey(config);
+            ATNConfig mergedConfig = mergedConfigs.Get(configKey);
+            if (mergedConfig != null && 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 new ATNConfigSet.ATNConfigSetIterator(this);
-		}
+        public virtual IEnumerator<ATNConfig> GetEnumerator()
+        {
+            return new ATNConfigSet.ATNConfigSetIterator(this);
+        }
 
-		public virtual object[] ToArray()
-		{
-			return Sharpen.Collections.ToArray(configs);
-		}
+        public virtual object[] ToArray()
+        {
+            return Sharpen.Collections.ToArray(configs);
+        }
 
-		public virtual T[] ToArray<T>(T[] a)
-		{
-			return Sharpen.Collections.ToArray(configs, a);
-		}
+        public virtual T[] ToArray<T>(T[] a)
+        {
+            return Sharpen.Collections.ToArray(configs, a);
+        }
 
-		public virtual bool AddItem(ATNConfig e)
-		{
-			return Add(e, null);
-		}
+        public virtual bool AddItem(ATNConfig e)
+        {
+            return Add(e, null);
+        }
 
-		public virtual bool Add(ATNConfig e, PredictionContextCache contextCache)
-		{
-			EnsureWritable();
-			System.Diagnostics.Debug.Assert(!outermostConfigSet || !e.GetReachesIntoOuterContext
-				());
-			System.Diagnostics.Debug.Assert(!e.IsHidden());
-			if (contextCache == null)
-			{
-				contextCache = PredictionContextCache.Uncached;
-			}
-			bool addKey;
-			long key = GetKey(e);
-			ATNConfig mergedConfig = mergedConfigs.Get(key);
-			addKey = (mergedConfig == null);
-			if (mergedConfig != null && CanMerge(e, key, mergedConfig))
-			{
-				mergedConfig.SetOuterContextDepth(Math.Max(mergedConfig.GetOuterContextDepth(), e
-					.GetOuterContextDepth()));
-				PredictionContext joined = PredictionContext.Join(mergedConfig.GetContext(), e.GetContext
-					(), contextCache);
-				UpdatePropertiesForMergedConfig(e);
-				if (mergedConfig.GetContext() == joined)
-				{
-					return false;
-				}
-				mergedConfig.SetContext(joined);
-				return true;
-			}
-			for (int i = 0; i < unmerged.Count; i++)
-			{
-				ATNConfig unmergedConfig = unmerged[i];
-				if (CanMerge(e, key, unmergedConfig))
-				{
-					unmergedConfig.SetOuterContextDepth(Math.Max(unmergedConfig.GetOuterContextDepth(
-						), e.GetOuterContextDepth()));
-					PredictionContext joined = PredictionContext.Join(unmergedConfig.GetContext(), e.
-						GetContext(), contextCache);
-					UpdatePropertiesForMergedConfig(e);
-					if (unmergedConfig.GetContext() == joined)
-					{
-						return false;
-					}
-					unmergedConfig.SetContext(joined);
-					if (addKey)
-					{
-						mergedConfigs.Put(key, unmergedConfig);
-						unmerged.Remove(i);
-					}
-					return true;
-				}
-			}
-			configs.AddItem(e);
-			if (addKey)
-			{
-				mergedConfigs.Put(key, e);
-			}
-			else
-			{
-				unmerged.AddItem(e);
-			}
-			UpdatePropertiesForAddedConfig(e);
-			return true;
-		}
+        public virtual bool Add(ATNConfig e, PredictionContextCache contextCache)
+        {
+            EnsureWritable();
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !e.GetReachesIntoOuterContext
+                ());
+            System.Diagnostics.Debug.Assert(!e.IsHidden());
+            if (contextCache == null)
+            {
+                contextCache = PredictionContextCache.Uncached;
+            }
+            bool addKey;
+            long key = GetKey(e);
+            ATNConfig mergedConfig = mergedConfigs.Get(key);
+            addKey = (mergedConfig == null);
+            if (mergedConfig != null && CanMerge(e, key, mergedConfig))
+            {
+                mergedConfig.SetOuterContextDepth(Math.Max(mergedConfig.GetOuterContextDepth(), e
+                    .GetOuterContextDepth()));
+                PredictionContext joined = PredictionContext.Join(mergedConfig.GetContext(), e.GetContext
+                    (), contextCache);
+                UpdatePropertiesForMergedConfig(e);
+                if (mergedConfig.GetContext() == joined)
+                {
+                    return false;
+                }
+                mergedConfig.SetContext(joined);
+                return true;
+            }
+            for (int i = 0; i < unmerged.Count; i++)
+            {
+                ATNConfig unmergedConfig = unmerged[i];
+                if (CanMerge(e, key, unmergedConfig))
+                {
+                    unmergedConfig.SetOuterContextDepth(Math.Max(unmergedConfig.GetOuterContextDepth(
+                        ), e.GetOuterContextDepth()));
+                    PredictionContext joined = PredictionContext.Join(unmergedConfig.GetContext(), e.
+                        GetContext(), contextCache);
+                    UpdatePropertiesForMergedConfig(e);
+                    if (unmergedConfig.GetContext() == joined)
+                    {
+                        return false;
+                    }
+                    unmergedConfig.SetContext(joined);
+                    if (addKey)
+                    {
+                        mergedConfigs.Put(key, unmergedConfig);
+                        unmerged.Remove(i);
+                    }
+                    return true;
+                }
+            }
+            configs.AddItem(e);
+            if (addKey)
+            {
+                mergedConfigs.Put(key, e);
+            }
+            else
+            {
+                unmerged.AddItem(e);
+            }
+            UpdatePropertiesForAddedConfig(e);
+            return true;
+        }
 
-		private void UpdatePropertiesForMergedConfig(ATNConfig config)
-		{
-			// merged configs can't change the alt or semantic context
-			dipsIntoOuterContext |= config.GetReachesIntoOuterContext();
-			System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
-		}
+        private void UpdatePropertiesForMergedConfig(ATNConfig config)
+        {
+            // merged configs can't change the alt or semantic context
+            dipsIntoOuterContext |= config.GetReachesIntoOuterContext();
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+        }
 
-		private void UpdatePropertiesForAddedConfig(ATNConfig config)
-		{
-			if (configs.Count == 1)
-			{
-				uniqueAlt = config.GetAlt();
-			}
-			else
-			{
-				if (uniqueAlt != config.GetAlt())
-				{
-					uniqueAlt = ATN.InvalidAltNumber;
-				}
-			}
-			hasSemanticContext |= !SemanticContext.None.Equals(config.GetSemanticContext());
-			dipsIntoOuterContext |= config.GetReachesIntoOuterContext();
-			System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
-		}
+        private void UpdatePropertiesForAddedConfig(ATNConfig config)
+        {
+            if (configs.Count == 1)
+            {
+                uniqueAlt = config.GetAlt();
+            }
+            else
+            {
+                if (uniqueAlt != config.GetAlt())
+                {
+                    uniqueAlt = ATN.InvalidAltNumber;
+                }
+            }
+            hasSemanticContext |= !SemanticContext.None.Equals(config.GetSemanticContext());
+            dipsIntoOuterContext |= config.GetReachesIntoOuterContext();
+            System.Diagnostics.Debug.Assert(!outermostConfigSet || !dipsIntoOuterContext);
+        }
 
-		protected internal virtual bool CanMerge(ATNConfig left, long leftKey, ATNConfig 
-			right)
-		{
-			if (left.GetState().stateNumber != right.GetState().stateNumber)
-			{
-				return false;
-			}
-			if (leftKey != GetKey(right))
-			{
-				return false;
-			}
-			return left.GetSemanticContext().Equals(right.GetSemanticContext());
-		}
+        protected internal virtual bool CanMerge(ATNConfig left, long leftKey, ATNConfig 
+            right)
+        {
+            if (left.GetState().stateNumber != right.GetState().stateNumber)
+            {
+                return false;
+            }
+            if (leftKey != GetKey(right))
+            {
+                return false;
+            }
+            return left.GetSemanticContext().Equals(right.GetSemanticContext());
+        }
 
-		protected internal virtual long GetKey(ATNConfig e)
-		{
-			long key = e.GetState().stateNumber;
-			key = (key << 12) | (e.GetAlt() & unchecked((int)(0xFFF)));
-			return key;
-		}
+        protected internal virtual long GetKey(ATNConfig e)
+        {
+            long key = e.GetState().stateNumber;
+            key = (key << 12) | (e.GetAlt() & unchecked((int)(0xFFF)));
+            return key;
+        }
 
-		public virtual bool Remove(object o)
-		{
-			EnsureWritable();
-			throw new NotSupportedException("Not supported yet.");
-		}
+        public virtual bool Remove(object o)
+        {
+            EnsureWritable();
+            throw new NotSupportedException("Not supported yet.");
+        }
 
-		public virtual bool ContainsAll<_T0>(ICollection<_T0> c)
-		{
-			foreach (object o in c)
-			{
-				if (!(o is ATNConfig))
-				{
-					return false;
-				}
-				if (!Contains((ATNConfig)o))
-				{
-					return false;
-				}
-			}
-			return true;
-		}
+        public virtual bool ContainsAll<_T0>(ICollection<_T0> c)
+        {
+            foreach (object o in c)
+            {
+                if (!(o is ATNConfig))
+                {
+                    return false;
+                }
+                if (!Contains((ATNConfig)o))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
 
-		public virtual bool AddAll<_T0>(ICollection<_T0> c) where _T0:ATNConfig
-		{
-			return AddAll(c, null);
-		}
+        public virtual bool AddAll<_T0>(ICollection<_T0> c) where _T0:ATNConfig
+        {
+            return AddAll(c, null);
+        }
 
-		public virtual bool AddAll<_T0>(ICollection<_T0> c, PredictionContextCache contextCache
-			) where _T0:ATNConfig
-		{
-			EnsureWritable();
-			bool changed = false;
-			foreach (ATNConfig group in c)
-			{
-				changed |= Add(group, contextCache);
-			}
-			return changed;
-		}
+        public virtual bool AddAll<_T0>(ICollection<_T0> c, PredictionContextCache contextCache
+            ) where _T0:ATNConfig
+        {
+            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 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 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;
-			conflictingAlts = null;
-		}
+        public virtual void Clear()
+        {
+            EnsureWritable();
+            mergedConfigs.Clear();
+            unmerged.Clear();
+            configs.Clear();
+            dipsIntoOuterContext = false;
+            hasSemanticContext = false;
+            uniqueAlt = ATN.InvalidAltNumber;
+            conflictingAlts = 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(conflictingAlts
-				, other.conflictingAlts) && configs.Equals(other.configs);
-		}
+        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(conflictingAlts
+                , other.conflictingAlts) && configs.Equals(other.configs);
+        }
 
-		public override int GetHashCode()
-		{
-			int hashCode = 1;
-			hashCode = 5 * hashCode ^ (outermostConfigSet ? 1 : 0);
-			hashCode = 5 * hashCode ^ configs.GetHashCode();
-			return hashCode;
-		}
+        public override int GetHashCode()
+        {
+            int hashCode = 1;
+            hashCode = 5 * hashCode ^ (outermostConfigSet ? 1 : 0);
+            hashCode = 5 * hashCode ^ configs.GetHashCode();
+            return hashCode;
+        }
 
-		public override string ToString()
-		{
-			return ToString(false);
-		}
+        public override string ToString()
+        {
+            return ToString(false);
+        }
 
-		public virtual string ToString(bool showContext)
-		{
-			StringBuilder buf = new StringBuilder();
-			IList<ATNConfig> sortedConfigs = new List<ATNConfig>(configs);
-			sortedConfigs.Sort(new _IComparer_467());
-			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 (conflictingAlts != null)
-			{
-				buf.Append(",conflictingAlts=").Append(conflictingAlts);
-			}
-			if (dipsIntoOuterContext)
-			{
-				buf.Append(",dipsIntoOuterContext");
-			}
-			return buf.ToString();
-		}
+        public virtual string ToString(bool showContext)
+        {
+            StringBuilder buf = new StringBuilder();
+            IList<ATNConfig> sortedConfigs = new List<ATNConfig>(configs);
+            sortedConfigs.Sort(new _IComparer_467());
+            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 (conflictingAlts != null)
+            {
+                buf.Append(",conflictingAlts=").Append(conflictingAlts);
+            }
+            if (dipsIntoOuterContext)
+            {
+                buf.Append(",dipsIntoOuterContext");
+            }
+            return buf.ToString();
+        }
 
-		private sealed class _IComparer_467 : IComparer<ATNConfig>
-		{
-			public _IComparer_467()
-			{
-			}
+        private sealed class _IComparer_467 : IComparer<ATNConfig>
+        {
+            public _IComparer_467()
+            {
+            }
 
-			public int Compare(ATNConfig o1, ATNConfig o2)
-			{
-				if (o1.GetAlt() != o2.GetAlt())
-				{
-					return o1.GetAlt() - o2.GetAlt();
-				}
-				else
-				{
-					if (o1.GetState().stateNumber != o2.GetState().stateNumber)
-					{
-						return o1.GetState().stateNumber - o2.GetState().stateNumber;
-					}
-					else
-					{
-						return Sharpen.Runtime.CompareOrdinal(o1.GetSemanticContext().ToString(), o2.GetSemanticContext
-							().ToString());
-					}
-				}
-			}
-		}
+            public int Compare(ATNConfig o1, ATNConfig o2)
+            {
+                if (o1.GetAlt() != o2.GetAlt())
+                {
+                    return o1.GetAlt() - o2.GetAlt();
+                }
+                else
+                {
+                    if (o1.GetState().stateNumber != o2.GetState().stateNumber)
+                    {
+                        return o1.GetState().stateNumber - o2.GetState().stateNumber;
+                    }
+                    else
+                    {
+                        return Sharpen.Runtime.CompareOrdinal(o1.GetSemanticContext().ToString(), o2.GetSemanticContext
+                            ().ToString());
+                    }
+                }
+            }
+        }
 
-		public virtual int GetUniqueAlt()
-		{
-			return uniqueAlt;
-		}
+        public virtual int GetUniqueAlt()
+        {
+            return uniqueAlt;
+        }
 
-		public virtual bool HasSemanticContext()
-		{
-			return hasSemanticContext;
-		}
+        public virtual bool HasSemanticContext()
+        {
+            return hasSemanticContext;
+        }
 
-		public virtual void ClearExplicitSemanticContext()
-		{
-			EnsureWritable();
-			hasSemanticContext = false;
-		}
+        public virtual void ClearExplicitSemanticContext()
+        {
+            EnsureWritable();
+            hasSemanticContext = false;
+        }
 
-		public virtual void MarkExplicitSemanticContext()
-		{
-			EnsureWritable();
-			hasSemanticContext = true;
-		}
+        public virtual void MarkExplicitSemanticContext()
+        {
+            EnsureWritable();
+            hasSemanticContext = true;
+        }
 
-		public virtual BitSet GetConflictingAlts()
-		{
-			return conflictingAlts;
-		}
+        public virtual BitSet GetConflictingAlts()
+        {
+            return conflictingAlts;
+        }
 
-		public virtual void SetConflictingAlts(BitSet conflictingAlts)
-		{
-			EnsureWritable();
-			this.conflictingAlts = conflictingAlts;
-		}
+        public virtual void SetConflictingAlts(BitSet conflictingAlts)
+        {
+            EnsureWritable();
+            this.conflictingAlts = conflictingAlts;
+        }
 
-		public virtual bool GetDipsIntoOuterContext()
-		{
-			return dipsIntoOuterContext;
-		}
+        public virtual bool GetDipsIntoOuterContext()
+        {
+            return dipsIntoOuterContext;
+        }
 
-		public virtual ATNConfig Get(int index)
-		{
-			return configs[index];
-		}
+        public virtual ATNConfig Get(int index)
+        {
+            return configs[index];
+        }
 
-		public virtual void Remove(int index)
-		{
-			EnsureWritable();
-			ATNConfig config = configs[index];
-			configs.Remove(config);
-			long key = GetKey(config);
-			if (mergedConfigs.Get(key) == config)
-			{
-				Sharpen.Collections.Remove(mergedConfigs, key);
-			}
-			else
-			{
-				for (int i = 0; i < unmerged.Count; i++)
-				{
-					if (unmerged[i] == config)
-					{
-						unmerged.Remove(i);
-						return;
-					}
-				}
-			}
-		}
+        public virtual void Remove(int index)
+        {
+            EnsureWritable();
+            ATNConfig config = configs[index];
+            configs.Remove(config);
+            long key = GetKey(config);
+            if (mergedConfigs.Get(key) == config)
+            {
+                Sharpen.Collections.Remove(mergedConfigs, key);
+            }
+            else
+            {
+                for (int i = 0; i < unmerged.Count; i++)
+                {
+                    if (unmerged[i] == config)
+                    {
+                        unmerged.Remove(i);
+                        return;
+                    }
+                }
+            }
+        }
 
-		protected internal void EnsureWritable()
-		{
-			if (IsReadOnly())
-			{
-				throw new InvalidOperationException("This ATNConfigSet is read only.");
-			}
-		}
+        protected internal void EnsureWritable()
+        {
+            if (IsReadOnly())
+            {
+                throw new InvalidOperationException("This ATNConfigSet is read only.");
+            }
+        }
 
-		private sealed class ATNConfigSetIterator : IEnumerator<ATNConfig>
-		{
-			internal int index = -1;
+        private sealed class ATNConfigSetIterator : IEnumerator<ATNConfig>
+        {
+            internal int index = -1;
 
-			internal bool removed = false;
+            internal bool removed = false;
 
-			public override bool HasNext()
-			{
-				return this.index + 1 < this._enclosing.configs.Count;
-			}
+            public override bool HasNext()
+            {
+                return this.index + 1 < this._enclosing.configs.Count;
+            }
 
-			public override ATNConfig Next()
-			{
-				if (!this.HasNext())
-				{
-					throw new NoSuchElementException();
-				}
-				this.index++;
-				this.removed = false;
-				return this._enclosing.configs[this.index];
-			}
+            public override ATNConfig Next()
+            {
+                if (!this.HasNext())
+                {
+                    throw new NoSuchElementException();
+                }
+                this.index++;
+                this.removed = false;
+                return this._enclosing.configs[this.index];
+            }
 
-			public override void Remove()
-			{
-				if (this.removed || this.index < 0 || this.index >= this._enclosing.configs.Count)
-				{
-					throw new InvalidOperationException();
-				}
-				this._enclosing.Remove(this.index);
-				this.removed = true;
-			}
+            public override void Remove()
+            {
+                if (this.removed || this.index < 0 || this.index >= this._enclosing.configs.Count)
+                {
+                    throw new InvalidOperationException();
+                }
+                this._enclosing.Remove(this.index);
+                this.removed = true;
+            }
 
-			internal ATNConfigSetIterator(ATNConfigSet _enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal ATNConfigSetIterator(ATNConfigSet _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly ATNConfigSet _enclosing;
-		}
-	}
+            private readonly ATNConfigSet _enclosing;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ATNSimulator.cs b/Antlr4.Runtime/Atn/ATNSimulator.cs
index b9637ea18..325ff66a1 100644
--- a/Antlr4.Runtime/Atn/ATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ATNSimulator.cs
@@ -37,959 +37,959 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public abstract class ATNSimulator
-	{
-		public static readonly int SerializedVersion;
+    public abstract class ATNSimulator
+    {
+        public static readonly int SerializedVersion;
 
-		static ATNSimulator()
-		{
-			SerializedVersion = 5;
-		}
+        static ATNSimulator()
+        {
+            SerializedVersion = 5;
+        }
 
-		public const char RuleVariantDelimiter = '$';
+        public const char RuleVariantDelimiter = '$';
 
-		public static readonly string RuleLfVariantMarker = "$lf$";
+        public static readonly string RuleLfVariantMarker = "$lf$";
 
-		public static readonly string RuleNolfVariantMarker = "$nolf$";
+        public static readonly string RuleNolfVariantMarker = "$nolf$";
 
-		/// <summary>Must distinguish between missing edge and edge we know leads nowhere</summary>
-		[NotNull]
-		public static readonly DFAState Error;
+        /// <summary>Must distinguish between missing edge and edge we know leads nowhere</summary>
+        [NotNull]
+        public static readonly DFAState Error;
 
-		[NotNull]
-		public readonly ATN atn;
+        [NotNull]
+        public readonly ATN atn;
 
-		static ATNSimulator()
-		{
-			Error = new DFAState(new ATNConfigSet(), 0, 0);
-			Error.stateNumber = int.MaxValue;
-		}
+        static ATNSimulator()
+        {
+            Error = new DFAState(new ATNConfigSet(), 0, 0);
+            Error.stateNumber = int.MaxValue;
+        }
 
-		public ATNSimulator(ATN atn)
-		{
-			this.atn = atn;
-		}
+        public ATNSimulator(ATN atn)
+        {
+            this.atn = atn;
+        }
 
-		public abstract void Reset();
+        public abstract void Reset();
 
-		public static ATN Deserialize(char[] data)
-		{
-			return Deserialize(data, true);
-		}
+        public static ATN Deserialize(char[] data)
+        {
+            return Deserialize(data, true);
+        }
 
-		public static ATN Deserialize(char[] data, bool optimize)
-		{
-			data = data.Clone();
-			// don't adjust the first value since that's the version number
-			for (int i = 1; i < data.Length; i++)
-			{
-				data[i] = (char)(data[i] - 2);
-			}
-			ATN atn = new ATN();
-			IList<IntervalSet> sets = new List<IntervalSet>();
-			int p = 0;
-			int version = ToInt(data[p++]);
-			if (version != SerializedVersion)
-			{
-				string reason = string.Format("Could not deserialize ATN with version %d (expected %d)."
-					, version, SerializedVersion);
-				throw new NotSupportedException(new InvalidClassException(typeof(ATN).FullName, reason
-					));
-			}
-			atn.grammarType = ToInt(data[p++]);
-			atn.maxTokenType = ToInt(data[p++]);
-			//
-			// STATES
-			//
-			IList<Tuple<LoopEndState, int>> loopBackStateNumbers = new List<Tuple<LoopEndState
-				, int>>();
-			IList<Tuple<BlockStartState, int>> endStateNumbers = new List<Tuple<BlockStartState
-				, int>>();
-			int nstates = ToInt(data[p++]);
-			for (int i_1 = 1; i_1 <= nstates; i_1++)
-			{
-				int stype = ToInt(data[p++]);
-				// ignore bad type of states
-				if (stype == ATNState.InvalidType)
-				{
-					atn.AddState(null);
-					continue;
-				}
-				int ruleIndex = ToInt(data[p++]);
-				ATNState s = StateFactory(stype, ruleIndex);
-				if (stype == ATNState.LoopEnd)
-				{
-					// special case
-					int loopBackStateNumber = ToInt(data[p++]);
-					loopBackStateNumbers.AddItem(Tuple.Create((LoopEndState)s, loopBackStateNumber));
-				}
-				else
-				{
-					if (s is BlockStartState)
-					{
-						int endStateNumber = ToInt(data[p++]);
-						endStateNumbers.AddItem(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.GetItem1().loopBackState = atn.states[pair.GetItem2()];
-			}
-			foreach (Tuple<BlockStartState, int> pair_1 in endStateNumbers)
-			{
-				pair_1.GetItem1().endState = (BlockEndState)atn.states[pair_1.GetItem2()];
-			}
-			int numNonGreedyStates = ToInt(data[p++]);
-			for (int i_2 = 0; i_2 < numNonGreedyStates; i_2++)
-			{
-				int stateNumber = ToInt(data[p++]);
-				((DecisionState)atn.states[stateNumber]).nonGreedy = true;
-			}
-			int numSllDecisions = ToInt(data[p++]);
-			for (int i_3 = 0; i_3 < numSllDecisions; i_3++)
-			{
-				int stateNumber = ToInt(data[p++]);
-				((DecisionState)atn.states[stateNumber]).sll = true;
-			}
-			int numPrecedenceStates = ToInt(data[p++]);
-			for (int i_4 = 0; i_4 < numPrecedenceStates; i_4++)
-			{
-				int stateNumber = ToInt(data[p++]);
-				((RuleStartState)atn.states[stateNumber]).isPrecedenceRule = true;
-			}
-			//
-			// RULES
-			//
-			int nrules = ToInt(data[p++]);
-			if (atn.grammarType == ATN.Lexer)
-			{
-				atn.ruleToTokenType = new int[nrules];
-				atn.ruleToActionIndex = new int[nrules];
-			}
-			atn.ruleToStartState = new RuleStartState[nrules];
-			for (int i_5 = 0; i_5 < nrules; i_5++)
-			{
-				int s = ToInt(data[p++]);
-				RuleStartState startState = (RuleStartState)atn.states[s];
-				startState.leftFactored = ToInt(data[p++]) != 0;
-				atn.ruleToStartState[i_5] = startState;
-				if (atn.grammarType == ATN.Lexer)
-				{
-					int tokenType = ToInt(data[p++]);
-					atn.ruleToTokenType[i_5] = tokenType;
-					int actionIndex = ToInt(data[p++]);
-					atn.ruleToActionIndex[i_5] = actionIndex;
-				}
-			}
-			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;
-			}
-			//
-			// MODES
-			//
-			int nmodes = ToInt(data[p++]);
-			for (int i_6 = 0; i_6 < nmodes; i_6++)
-			{
-				int s = ToInt(data[p++]);
-				atn.modeToStartState.AddItem((TokensStartState)atn.states[s]);
-			}
-			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]);
-			}
-			//
-			// SETS
-			//
-			int nsets = ToInt(data[p++]);
-			for (int i_8 = 1; i_8 <= nsets; i_8++)
-			{
-				int nintervals = ToInt(data[p]);
-				p++;
-				IntervalSet set = new IntervalSet();
-				sets.AddItem(set);
-				for (int j = 1; j <= nintervals; j++)
-				{
-					set.Add(ToInt(data[p]), ToInt(data[p + 1]));
-					p += 2;
-				}
-			}
-			//
-			// EDGES
-			//
-			int nedges = ToInt(data[p++]);
-			for (int i_9 = 1; i_9 <= nedges; i_9++)
-			{
-				int src = ToInt(data[p]);
-				int trg = ToInt(data[p + 1]);
-				int ttype = ToInt(data[p + 2]);
-				int arg1 = ToInt(data[p + 3]);
-				int arg2 = ToInt(data[p + 4]);
-				int arg3 = ToInt(data[p + 5]);
-				Transition trans = EdgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
-				//			System.out.println("EDGE "+trans.getClass().getSimpleName()+" "+
-				//							   src+"->"+trg+
-				//					   " "+Transition.serializationNames[ttype]+
-				//					   " "+arg1+","+arg2+","+arg3);
-				ATNState srcState = atn.states[src];
-				srcState.AddTransition(trans);
-				p += 6;
-			}
-			// edges for rule stop states can be derived, so they aren't serialized
-			foreach (ATNState state_1 in atn.states)
-			{
-				bool returningToLeftFactored = state_1.ruleIndex >= 0 && atn.ruleToStartState[state_1
-					.ruleIndex].leftFactored;
-				for (int i_10 = 0; i_10 < state_1.GetNumberOfTransitions(); i_10++)
-				{
-					Transition t = state_1.Transition(i_10);
-					if (!(t is RuleTransition))
-					{
-						continue;
-					}
-					RuleTransition ruleTransition = (RuleTransition)t;
-					bool returningFromLeftFactored = atn.ruleToStartState[ruleTransition.target.ruleIndex
-						].leftFactored;
-					if (!returningFromLeftFactored && returningToLeftFactored)
-					{
-						continue;
-					}
-					atn.ruleToStopState[ruleTransition.target.ruleIndex].AddTransition(new EpsilonTransition
-						(ruleTransition.followState));
-				}
-			}
-			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;
-				}
-				if (state_2 is PlusLoopbackState)
-				{
-					PlusLoopbackState loopbackState = (PlusLoopbackState)state_2;
-					for (int i_10 = 0; i_10 < loopbackState.GetNumberOfTransitions(); 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.GetNumberOfTransitions(); i_10++)
-						{
-							ATNState target = loopbackState.Transition(i_10).target;
-							if (target is StarLoopEntryState)
-							{
-								((StarLoopEntryState)target).loopBackState = loopbackState;
-							}
-						}
-					}
-				}
-			}
-			//
-			// DECISIONS
-			//
-			int ndecisions = ToInt(data[p++]);
-			for (int i_11 = 1; i_11 <= ndecisions; i_11++)
-			{
-				int s = ToInt(data[p++]);
-				DecisionState decState = (DecisionState)atn.states[s];
-				atn.decisionToState.AddItem(decState);
-				decState.decision = i_11 - 1;
-			}
-			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);
-			}
-			if (optimize)
-			{
-				while (true)
-				{
-					int optimizationCount = 0;
-					optimizationCount += InlineSetRules(atn);
-					optimizationCount += CombineChainedEpsilons(atn);
-					bool preserveOrder = atn.grammarType == ATN.Lexer;
-					optimizationCount += OptimizeSets(atn, preserveOrder);
-					if (optimizationCount == 0)
-					{
-						break;
-					}
-				}
-			}
-			IdentifyTailCalls(atn);
-			VerifyATN(atn);
-			return atn;
-		}
+        public static ATN Deserialize(char[] data, bool optimize)
+        {
+            data = data.Clone();
+            // don't adjust the first value since that's the version number
+            for (int i = 1; i < data.Length; i++)
+            {
+                data[i] = (char)(data[i] - 2);
+            }
+            ATN atn = new ATN();
+            IList<IntervalSet> sets = new List<IntervalSet>();
+            int p = 0;
+            int version = ToInt(data[p++]);
+            if (version != SerializedVersion)
+            {
+                string reason = string.Format("Could not deserialize ATN with version %d (expected %d)."
+                    , version, SerializedVersion);
+                throw new NotSupportedException(new InvalidClassException(typeof(ATN).FullName, reason
+                    ));
+            }
+            atn.grammarType = ToInt(data[p++]);
+            atn.maxTokenType = ToInt(data[p++]);
+            //
+            // STATES
+            //
+            IList<Tuple<LoopEndState, int>> loopBackStateNumbers = new List<Tuple<LoopEndState
+                , int>>();
+            IList<Tuple<BlockStartState, int>> endStateNumbers = new List<Tuple<BlockStartState
+                , int>>();
+            int nstates = ToInt(data[p++]);
+            for (int i_1 = 1; i_1 <= nstates; i_1++)
+            {
+                int stype = ToInt(data[p++]);
+                // ignore bad type of states
+                if (stype == ATNState.InvalidType)
+                {
+                    atn.AddState(null);
+                    continue;
+                }
+                int ruleIndex = ToInt(data[p++]);
+                ATNState s = StateFactory(stype, ruleIndex);
+                if (stype == ATNState.LoopEnd)
+                {
+                    // special case
+                    int loopBackStateNumber = ToInt(data[p++]);
+                    loopBackStateNumbers.AddItem(Tuple.Create((LoopEndState)s, loopBackStateNumber));
+                }
+                else
+                {
+                    if (s is BlockStartState)
+                    {
+                        int endStateNumber = ToInt(data[p++]);
+                        endStateNumbers.AddItem(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.GetItem1().loopBackState = atn.states[pair.GetItem2()];
+            }
+            foreach (Tuple<BlockStartState, int> pair_1 in endStateNumbers)
+            {
+                pair_1.GetItem1().endState = (BlockEndState)atn.states[pair_1.GetItem2()];
+            }
+            int numNonGreedyStates = ToInt(data[p++]);
+            for (int i_2 = 0; i_2 < numNonGreedyStates; i_2++)
+            {
+                int stateNumber = ToInt(data[p++]);
+                ((DecisionState)atn.states[stateNumber]).nonGreedy = true;
+            }
+            int numSllDecisions = ToInt(data[p++]);
+            for (int i_3 = 0; i_3 < numSllDecisions; i_3++)
+            {
+                int stateNumber = ToInt(data[p++]);
+                ((DecisionState)atn.states[stateNumber]).sll = true;
+            }
+            int numPrecedenceStates = ToInt(data[p++]);
+            for (int i_4 = 0; i_4 < numPrecedenceStates; i_4++)
+            {
+                int stateNumber = ToInt(data[p++]);
+                ((RuleStartState)atn.states[stateNumber]).isPrecedenceRule = true;
+            }
+            //
+            // RULES
+            //
+            int nrules = ToInt(data[p++]);
+            if (atn.grammarType == ATN.Lexer)
+            {
+                atn.ruleToTokenType = new int[nrules];
+                atn.ruleToActionIndex = new int[nrules];
+            }
+            atn.ruleToStartState = new RuleStartState[nrules];
+            for (int i_5 = 0; i_5 < nrules; i_5++)
+            {
+                int s = ToInt(data[p++]);
+                RuleStartState startState = (RuleStartState)atn.states[s];
+                startState.leftFactored = ToInt(data[p++]) != 0;
+                atn.ruleToStartState[i_5] = startState;
+                if (atn.grammarType == ATN.Lexer)
+                {
+                    int tokenType = ToInt(data[p++]);
+                    atn.ruleToTokenType[i_5] = tokenType;
+                    int actionIndex = ToInt(data[p++]);
+                    atn.ruleToActionIndex[i_5] = actionIndex;
+                }
+            }
+            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;
+            }
+            //
+            // MODES
+            //
+            int nmodes = ToInt(data[p++]);
+            for (int i_6 = 0; i_6 < nmodes; i_6++)
+            {
+                int s = ToInt(data[p++]);
+                atn.modeToStartState.AddItem((TokensStartState)atn.states[s]);
+            }
+            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]);
+            }
+            //
+            // SETS
+            //
+            int nsets = ToInt(data[p++]);
+            for (int i_8 = 1; i_8 <= nsets; i_8++)
+            {
+                int nintervals = ToInt(data[p]);
+                p++;
+                IntervalSet set = new IntervalSet();
+                sets.AddItem(set);
+                for (int j = 1; j <= nintervals; j++)
+                {
+                    set.Add(ToInt(data[p]), ToInt(data[p + 1]));
+                    p += 2;
+                }
+            }
+            //
+            // EDGES
+            //
+            int nedges = ToInt(data[p++]);
+            for (int i_9 = 1; i_9 <= nedges; i_9++)
+            {
+                int src = ToInt(data[p]);
+                int trg = ToInt(data[p + 1]);
+                int ttype = ToInt(data[p + 2]);
+                int arg1 = ToInt(data[p + 3]);
+                int arg2 = ToInt(data[p + 4]);
+                int arg3 = ToInt(data[p + 5]);
+                Transition trans = EdgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
+                //			System.out.println("EDGE "+trans.getClass().getSimpleName()+" "+
+                //							   src+"->"+trg+
+                //					   " "+Transition.serializationNames[ttype]+
+                //					   " "+arg1+","+arg2+","+arg3);
+                ATNState srcState = atn.states[src];
+                srcState.AddTransition(trans);
+                p += 6;
+            }
+            // edges for rule stop states can be derived, so they aren't serialized
+            foreach (ATNState state_1 in atn.states)
+            {
+                bool returningToLeftFactored = state_1.ruleIndex >= 0 && atn.ruleToStartState[state_1
+                    .ruleIndex].leftFactored;
+                for (int i_10 = 0; i_10 < state_1.GetNumberOfTransitions(); i_10++)
+                {
+                    Transition t = state_1.Transition(i_10);
+                    if (!(t is RuleTransition))
+                    {
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)t;
+                    bool returningFromLeftFactored = atn.ruleToStartState[ruleTransition.target.ruleIndex
+                        ].leftFactored;
+                    if (!returningFromLeftFactored && returningToLeftFactored)
+                    {
+                        continue;
+                    }
+                    atn.ruleToStopState[ruleTransition.target.ruleIndex].AddTransition(new EpsilonTransition
+                        (ruleTransition.followState));
+                }
+            }
+            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;
+                }
+                if (state_2 is PlusLoopbackState)
+                {
+                    PlusLoopbackState loopbackState = (PlusLoopbackState)state_2;
+                    for (int i_10 = 0; i_10 < loopbackState.GetNumberOfTransitions(); 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.GetNumberOfTransitions(); i_10++)
+                        {
+                            ATNState target = loopbackState.Transition(i_10).target;
+                            if (target is StarLoopEntryState)
+                            {
+                                ((StarLoopEntryState)target).loopBackState = loopbackState;
+                            }
+                        }
+                    }
+                }
+            }
+            //
+            // DECISIONS
+            //
+            int ndecisions = ToInt(data[p++]);
+            for (int i_11 = 1; i_11 <= ndecisions; i_11++)
+            {
+                int s = ToInt(data[p++]);
+                DecisionState decState = (DecisionState)atn.states[s];
+                atn.decisionToState.AddItem(decState);
+                decState.decision = i_11 - 1;
+            }
+            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);
+            }
+            if (optimize)
+            {
+                while (true)
+                {
+                    int optimizationCount = 0;
+                    optimizationCount += InlineSetRules(atn);
+                    optimizationCount += CombineChainedEpsilons(atn);
+                    bool preserveOrder = atn.grammarType == ATN.Lexer;
+                    optimizationCount += OptimizeSets(atn, preserveOrder);
+                    if (optimizationCount == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+            IdentifyTailCalls(atn);
+            VerifyATN(atn);
+            return atn;
+        }
 
-		private static void VerifyATN(ATN atn)
-		{
-			// verify assumptions
-			foreach (ATNState state in atn.states)
-			{
-				if (state == null)
-				{
-					continue;
-				}
-				CheckCondition(state.OnlyHasEpsilonTransitions() || state.GetNumberOfTransitions(
-					) <= 1);
-				if (state is PlusBlockStartState)
-				{
-					CheckCondition(((PlusBlockStartState)state).loopBackState != null);
-				}
-				if (state is StarLoopEntryState)
-				{
-					StarLoopEntryState starLoopEntryState = (StarLoopEntryState)state;
-					CheckCondition(starLoopEntryState.loopBackState != null);
-					CheckCondition(starLoopEntryState.GetNumberOfTransitions() == 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.GetNumberOfTransitions() == 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.GetNumberOfTransitions() <= 1 || decisionState.decision
-						 >= 0);
-				}
-				else
-				{
-					CheckCondition(state.GetNumberOfTransitions() <= 1 || state is RuleStopState);
-				}
-			}
-		}
+        private static void VerifyATN(ATN atn)
+        {
+            // verify assumptions
+            foreach (ATNState state in atn.states)
+            {
+                if (state == null)
+                {
+                    continue;
+                }
+                CheckCondition(state.OnlyHasEpsilonTransitions() || state.GetNumberOfTransitions(
+                    ) <= 1);
+                if (state is PlusBlockStartState)
+                {
+                    CheckCondition(((PlusBlockStartState)state).loopBackState != null);
+                }
+                if (state is StarLoopEntryState)
+                {
+                    StarLoopEntryState starLoopEntryState = (StarLoopEntryState)state;
+                    CheckCondition(starLoopEntryState.loopBackState != null);
+                    CheckCondition(starLoopEntryState.GetNumberOfTransitions() == 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.GetNumberOfTransitions() == 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.GetNumberOfTransitions() <= 1 || decisionState.decision
+                         >= 0);
+                }
+                else
+                {
+                    CheckCondition(state.GetNumberOfTransitions() <= 1 || state is RuleStopState);
+                }
+            }
+        }
 
-		public static void CheckCondition(bool condition)
-		{
-			CheckCondition(condition, null);
-		}
+        public static void CheckCondition(bool condition)
+        {
+            CheckCondition(condition, null);
+        }
 
-		public static void CheckCondition(bool condition, string message)
-		{
-			if (!condition)
-			{
-				throw new InvalidOperationException(message);
-			}
-		}
+        public static 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.GetNumberOfOptimizedTransitions
-					() == 1 && middleState.GetOptimizedTransition(0).SerializationType == Transition
-					.Epsilon)
-				{
-					middleState = middleState.GetOptimizedTransition(0).target;
-				}
-				if (middleState.GetNumberOfOptimizedTransitions() != 1)
-				{
-					continue;
-				}
-				Transition matchTransition = middleState.GetOptimizedTransition(0);
-				ATNState matchTarget = matchTransition.target;
-				if (matchTransition.IsEpsilon || !matchTarget.OnlyHasEpsilonTransitions() || matchTarget
-					.GetNumberOfOptimizedTransitions() != 1 || !(matchTarget.GetOptimizedTransition(
-					0).target is RuleStopState))
-				{
-					continue;
-				}
-				switch (matchTransition.SerializationType)
-				{
-					case Transition.Atom:
-					case Transition.Range:
-					case Transition.Set:
-					{
-						ruleToInlineTransition[i] = matchTransition;
-						break;
-					}
+        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.GetNumberOfOptimizedTransitions
+                    () == 1 && middleState.GetOptimizedTransition(0).SerializationType == Transition
+                    .Epsilon)
+                {
+                    middleState = middleState.GetOptimizedTransition(0).target;
+                }
+                if (middleState.GetNumberOfOptimizedTransitions() != 1)
+                {
+                    continue;
+                }
+                Transition matchTransition = middleState.GetOptimizedTransition(0);
+                ATNState matchTarget = matchTransition.target;
+                if (matchTransition.IsEpsilon || !matchTarget.OnlyHasEpsilonTransitions() || matchTarget
+                    .GetNumberOfOptimizedTransitions() != 1 || !(matchTarget.GetOptimizedTransition
+                    (0).target is RuleStopState))
+                {
+                    continue;
+                }
+                switch (matchTransition.SerializationType)
+                {
+                    case Transition.Atom:
+                    case Transition.Range:
+                    case Transition.Set:
+                    {
+                        ruleToInlineTransition[i] = matchTransition;
+                        break;
+                    }
 
-					case Transition.NotSet:
-					case Transition.Wildcard:
-					{
-						// not implemented yet
-						continue;
-						goto default;
-					}
+                    case Transition.NotSet:
+                    case Transition.Wildcard:
+                    {
+                        // not implemented yet
+                        continue;
+                        goto default;
+                    }
 
-					default:
-					{
-						continue;
-						break;
-					}
-				}
-			}
-			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.GetNumberOfOptimizedTransitions(); i_1++)
-				{
-					Transition transition = state.GetOptimizedTransition(i_1);
-					if (!(transition is RuleTransition))
-					{
-						if (optimizedTransitions != null)
-						{
-							optimizedTransitions.AddItem(transition);
-						}
-						continue;
-					}
-					RuleTransition ruleTransition = (RuleTransition)transition;
-					Transition effective = ruleToInlineTransition[ruleTransition.target.ruleIndex];
-					if (effective == null)
-					{
-						if (optimizedTransitions != null)
-						{
-							optimizedTransitions.AddItem(transition);
-						}
-						continue;
-					}
-					if (optimizedTransitions == null)
-					{
-						optimizedTransitions = new List<Transition>();
-						for (int j = 0; j < i_1; j++)
-						{
-							optimizedTransitions.AddItem(state.GetOptimizedTransition(i_1));
-						}
-					}
-					inlinedCalls++;
-					ATNState target = ruleTransition.followState;
-					ATNState intermediateState = new BasicState();
-					intermediateState.SetRuleIndex(target.ruleIndex);
-					atn.AddState(intermediateState);
-					optimizedTransitions.AddItem(new EpsilonTransition(intermediateState));
-					switch (effective.SerializationType)
-					{
-						case Transition.Atom:
-						{
-							intermediateState.AddTransition(new AtomTransition(target, ((AtomTransition)effective
-								).label));
-							break;
-						}
+                    default:
+                    {
+                        continue;
+                        break;
+                    }
+                }
+            }
+            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.GetNumberOfOptimizedTransitions(); i_1++)
+                {
+                    Transition transition = state.GetOptimizedTransition(i_1);
+                    if (!(transition is RuleTransition))
+                    {
+                        if (optimizedTransitions != null)
+                        {
+                            optimizedTransitions.AddItem(transition);
+                        }
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition;
+                    Transition effective = ruleToInlineTransition[ruleTransition.target.ruleIndex];
+                    if (effective == null)
+                    {
+                        if (optimizedTransitions != null)
+                        {
+                            optimizedTransitions.AddItem(transition);
+                        }
+                        continue;
+                    }
+                    if (optimizedTransitions == null)
+                    {
+                        optimizedTransitions = new List<Transition>();
+                        for (int j = 0; j < i_1; j++)
+                        {
+                            optimizedTransitions.AddItem(state.GetOptimizedTransition(i_1));
+                        }
+                    }
+                    inlinedCalls++;
+                    ATNState target = ruleTransition.followState;
+                    ATNState intermediateState = new BasicState();
+                    intermediateState.SetRuleIndex(target.ruleIndex);
+                    atn.AddState(intermediateState);
+                    optimizedTransitions.AddItem(new EpsilonTransition(intermediateState));
+                    switch (effective.SerializationType)
+                    {
+                        case Transition.Atom:
+                        {
+                            intermediateState.AddTransition(new AtomTransition(target, ((AtomTransition)effective
+                                ).label));
+                            break;
+                        }
 
-						case Transition.Range:
-						{
-							intermediateState.AddTransition(new RangeTransition(target, ((RangeTransition)effective
-								).from, ((RangeTransition)effective).to));
-							break;
-						}
+                        case Transition.Range:
+                        {
+                            intermediateState.AddTransition(new RangeTransition(target, ((RangeTransition)effective
+                                ).from, ((RangeTransition)effective).to));
+                            break;
+                        }
 
-						case Transition.Set:
-						{
-							intermediateState.AddTransition(new SetTransition(target, effective.Label));
-							break;
-						}
+                        case Transition.Set:
+                        {
+                            intermediateState.AddTransition(new SetTransition(target, effective.Label));
+                            break;
+                        }
 
-						default:
-						{
-							throw new NotSupportedException();
-						}
-					}
-				}
-				if (optimizedTransitions != null)
-				{
-					if (state.IsOptimized())
-					{
-						while (state.GetNumberOfOptimizedTransitions() > 0)
-						{
-							state.RemoveOptimizedTransition(state.GetNumberOfOptimizedTransitions() - 1);
-						}
-					}
-					foreach (Transition transition in optimizedTransitions)
-					{
-						state.AddOptimizedTransition(transition);
-					}
-				}
-			}
-			return inlinedCalls;
-		}
+                        default:
+                        {
+                            throw new NotSupportedException();
+                        }
+                    }
+                }
+                if (optimizedTransitions != null)
+                {
+                    if (state.IsOptimized())
+                    {
+                        while (state.GetNumberOfOptimizedTransitions() > 0)
+                        {
+                            state.RemoveOptimizedTransition(state.GetNumberOfOptimizedTransitions() - 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.GetNumberOfOptimizedTransitions(); i++)
-				{
-					Transition transition = state.GetOptimizedTransition(i);
-					ATNState intermediate = transition.target;
-					if (transition.SerializationType != Transition.Epsilon || intermediate.GetStateType
-						() != ATNState.Basic || !intermediate.OnlyHasEpsilonTransitions())
-					{
-						if (optimizedTransitions != null)
-						{
-							optimizedTransitions.AddItem(transition);
-						}
-						goto nextTransition_continue;
-					}
-					for (int j = 0; j < intermediate.GetNumberOfOptimizedTransitions(); j++)
-					{
-						if (intermediate.GetOptimizedTransition(j).SerializationType != Transition.Epsilon)
-						{
-							if (optimizedTransitions != null)
-							{
-								optimizedTransitions.AddItem(transition);
-							}
-							goto nextTransition_continue;
-						}
-					}
-					removedEdges++;
-					if (optimizedTransitions == null)
-					{
-						optimizedTransitions = new List<Transition>();
-						for (int j_1 = 0; j_1 < i; j_1++)
-						{
-							optimizedTransitions.AddItem(state.GetOptimizedTransition(j_1));
-						}
-					}
-					for (int j_2 = 0; j_2 < intermediate.GetNumberOfOptimizedTransitions(); j_2++)
-					{
-						ATNState target = intermediate.GetOptimizedTransition(j_2).target;
-						optimizedTransitions.AddItem(new EpsilonTransition(target));
-					}
+        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.GetNumberOfOptimizedTransitions(); i++)
+                {
+                    Transition transition = state.GetOptimizedTransition(i);
+                    ATNState intermediate = transition.target;
+                    if (transition.SerializationType != Transition.Epsilon || intermediate.GetStateType
+                        () != ATNState.Basic || !intermediate.OnlyHasEpsilonTransitions())
+                    {
+                        if (optimizedTransitions != null)
+                        {
+                            optimizedTransitions.AddItem(transition);
+                        }
+                        goto nextTransition_continue;
+                    }
+                    for (int j = 0; j < intermediate.GetNumberOfOptimizedTransitions(); j++)
+                    {
+                        if (intermediate.GetOptimizedTransition(j).SerializationType != Transition.Epsilon)
+                        {
+                            if (optimizedTransitions != null)
+                            {
+                                optimizedTransitions.AddItem(transition);
+                            }
+                            goto nextTransition_continue;
+                        }
+                    }
+                    removedEdges++;
+                    if (optimizedTransitions == null)
+                    {
+                        optimizedTransitions = new List<Transition>();
+                        for (int j_1 = 0; j_1 < i; j_1++)
+                        {
+                            optimizedTransitions.AddItem(state.GetOptimizedTransition(j_1));
+                        }
+                    }
+                    for (int j_2 = 0; j_2 < intermediate.GetNumberOfOptimizedTransitions(); j_2++)
+                    {
+                        ATNState target = intermediate.GetOptimizedTransition(j_2).target;
+                        optimizedTransitions.AddItem(new EpsilonTransition(target));
+                    }
 nextTransition_continue: ;
-				}
+                }
 nextTransition_break: ;
-				if (optimizedTransitions != null)
-				{
-					if (state.IsOptimized())
-					{
-						while (state.GetNumberOfOptimizedTransitions() > 0)
-						{
-							state.RemoveOptimizedTransition(state.GetNumberOfOptimizedTransitions() - 1);
-						}
-					}
-					foreach (Transition transition in optimizedTransitions)
-					{
-						state.AddOptimizedTransition(transition);
-					}
-				}
-			}
+                if (optimizedTransitions != null)
+                {
+                    if (state.IsOptimized())
+                    {
+                        while (state.GetNumberOfOptimizedTransitions() > 0)
+                        {
+                            state.RemoveOptimizedTransition(state.GetNumberOfOptimizedTransitions() - 1);
+                        }
+                    }
+                    foreach (Transition transition in optimizedTransitions)
+                    {
+                        state.AddOptimizedTransition(transition);
+                    }
+                }
+            }
 nextState_break: ;
-			return removedEdges;
-		}
+            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.GetNumberOfOptimizedTransitions(); i++)
-				{
-					Transition epsTransition = decision.GetOptimizedTransition(i);
-					if (!(epsTransition is EpsilonTransition))
-					{
-						continue;
-					}
-					if (epsTransition.target.GetNumberOfOptimizedTransitions() != 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.Size() <= 1)
-				{
-					continue;
-				}
-				IList<Transition> optimizedTransitions = new List<Transition>();
-				for (int i_1 = 0; i_1 < decision.GetNumberOfOptimizedTransitions(); i_1++)
-				{
-					if (!setTransitions.Contains(i_1))
-					{
-						optimizedTransitions.AddItem(decision.GetOptimizedTransition(i_1));
-					}
-				}
-				ATNState blockEndState = decision.GetOptimizedTransition(setTransitions.GetMinElement
-					()).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.Size() == 1)
-					{
-						newTransition = new AtomTransition(blockEndState, matchSet.GetMinElement());
-					}
-					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.AddItem(new EpsilonTransition(setOptimizedState));
-				removedPaths += decision.GetNumberOfOptimizedTransitions() - optimizedTransitions
-					.Count;
-				if (decision.IsOptimized())
-				{
-					while (decision.GetNumberOfOptimizedTransitions() > 0)
-					{
-						decision.RemoveOptimizedTransition(decision.GetNumberOfOptimizedTransitions() - 1
-							);
-					}
-				}
-				foreach (Transition transition_1 in optimizedTransitions)
-				{
-					decision.AddOptimizedTransition(transition_1);
-				}
-			}
-			return removedPaths;
-		}
+        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.GetNumberOfOptimizedTransitions(); i++)
+                {
+                    Transition epsTransition = decision.GetOptimizedTransition(i);
+                    if (!(epsTransition is EpsilonTransition))
+                    {
+                        continue;
+                    }
+                    if (epsTransition.target.GetNumberOfOptimizedTransitions() != 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.Size() <= 1)
+                {
+                    continue;
+                }
+                IList<Transition> optimizedTransitions = new List<Transition>();
+                for (int i_1 = 0; i_1 < decision.GetNumberOfOptimizedTransitions(); i_1++)
+                {
+                    if (!setTransitions.Contains(i_1))
+                    {
+                        optimizedTransitions.AddItem(decision.GetOptimizedTransition(i_1));
+                    }
+                }
+                ATNState blockEndState = decision.GetOptimizedTransition(setTransitions.GetMinElement
+                    ()).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.Size() == 1)
+                    {
+                        newTransition = new AtomTransition(blockEndState, matchSet.GetMinElement());
+                    }
+                    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.AddItem(new EpsilonTransition(setOptimizedState));
+                removedPaths += decision.GetNumberOfOptimizedTransitions() - optimizedTransitions
+                    .Count;
+                if (decision.IsOptimized())
+                {
+                    while (decision.GetNumberOfOptimizedTransitions() > 0)
+                    {
+                        decision.RemoveOptimizedTransition(decision.GetNumberOfOptimizedTransitions() - 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 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);
-			IDeque<ATNState> worklist = new ArrayDeque<ATNState>();
-			worklist.AddItem(transition.followState);
-			while (!worklist.IsEmpty())
-			{
-				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.SerializationType != Transition.Epsilon)
-					{
-						return false;
-					}
-					worklist.AddItem(t.target);
-				}
-			}
-			return 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);
+            IDeque<ATNState> worklist = new ArrayDeque<ATNState>();
+            worklist.AddItem(transition.followState);
+            while (!worklist.IsEmpty())
+            {
+                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.SerializationType != Transition.Epsilon)
+                    {
+                        return false;
+                    }
+                    worklist.AddItem(t.target);
+                }
+            }
+            return true;
+        }
 
-		public static int ToInt(char c)
-		{
-			return c == 65535 ? -1 : c;
-		}
+        public static int ToInt(char c)
+        {
+            return c == 65535 ? -1 : c;
+        }
 
-		[NotNull]
-		public static Transition EdgeFactory(ATN atn, int type, int src, int trg, int arg1
-			, int arg2, int arg3, IList<IntervalSet> sets)
-		{
-			ATNState target = atn.states[trg];
-			switch (type)
-			{
-				case Transition.Epsilon:
-				{
-					return new EpsilonTransition(target);
-				}
+        [NotNull]
+        public static Transition EdgeFactory(ATN atn, int type, int src, int trg, int arg1
+            , int arg2, int arg3, IList<IntervalSet> sets)
+        {
+            ATNState target = atn.states[trg];
+            switch (type)
+            {
+                case Transition.Epsilon:
+                {
+                    return new EpsilonTransition(target);
+                }
 
-				case Transition.Range:
-				{
-					return new RangeTransition(target, arg1, arg2);
-				}
+                case Transition.Range:
+                {
+                    return new RangeTransition(target, arg1, arg2);
+                }
 
-				case Transition.Rule:
-				{
-					RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3
-						, target);
-					return rt;
-				}
+                case Transition.Rule:
+                {
+                    RuleTransition rt = new RuleTransition((RuleStartState)atn.states[arg1], arg2, arg3
+                        , target);
+                    return rt;
+                }
 
-				case Transition.Predicate:
-				{
-					PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0);
-					return pt;
-				}
+                case Transition.Predicate:
+                {
+                    PredicateTransition pt = new PredicateTransition(target, arg1, arg2, arg3 != 0);
+                    return pt;
+                }
 
-				case Transition.Precedence:
-				{
-					return new PrecedencePredicateTransition(target, arg1);
-				}
+                case Transition.Precedence:
+                {
+                    return new PrecedencePredicateTransition(target, arg1);
+                }
 
-				case Transition.Atom:
-				{
-					return new AtomTransition(target, arg1);
-				}
+                case Transition.Atom:
+                {
+                    return new AtomTransition(target, arg1);
+                }
 
-				case Transition.Action:
-				{
-					ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0);
-					return a;
-				}
+                case Transition.Action:
+                {
+                    ActionTransition a = new ActionTransition(target, arg1, arg2, arg3 != 0);
+                    return a;
+                }
 
-				case Transition.Set:
-				{
-					return new SetTransition(target, sets[arg1]);
-				}
+                case Transition.Set:
+                {
+                    return new SetTransition(target, sets[arg1]);
+                }
 
-				case Transition.NotSet:
-				{
-					return new NotSetTransition(target, sets[arg1]);
-				}
+                case Transition.NotSet:
+                {
+                    return new NotSetTransition(target, sets[arg1]);
+                }
 
-				case Transition.Wildcard:
-				{
-					return new WildcardTransition(target);
-				}
-			}
-			throw new ArgumentException("The specified transition type is not valid.");
-		}
+                case Transition.Wildcard:
+                {
+                    return new WildcardTransition(target);
+                }
+            }
+            throw new ArgumentException("The specified transition type is not valid.");
+        }
 
-		public static ATNState StateFactory(int type, int ruleIndex)
-		{
-			ATNState s;
-			switch (type)
-			{
-				case ATNState.InvalidType:
-				{
-					return null;
-				}
+        public static ATNState StateFactory(int type, int ruleIndex)
+        {
+            ATNState s;
+            switch (type)
+            {
+                case ATNState.InvalidType:
+                {
+                    return null;
+                }
 
-				case ATNState.Basic:
-				{
-					s = new BasicState();
-					break;
-				}
+                case ATNState.Basic:
+                {
+                    s = new BasicState();
+                    break;
+                }
 
-				case ATNState.RuleStart:
-				{
-					s = new RuleStartState();
-					break;
-				}
+                case ATNState.RuleStart:
+                {
+                    s = new RuleStartState();
+                    break;
+                }
 
-				case ATNState.BlockStart:
-				{
-					s = new BasicBlockStartState();
-					break;
-				}
+                case ATNState.BlockStart:
+                {
+                    s = new BasicBlockStartState();
+                    break;
+                }
 
-				case ATNState.PlusBlockStart:
-				{
-					s = new PlusBlockStartState();
-					break;
-				}
+                case ATNState.PlusBlockStart:
+                {
+                    s = new PlusBlockStartState();
+                    break;
+                }
 
-				case ATNState.StarBlockStart:
-				{
-					s = new StarBlockStartState();
-					break;
-				}
+                case ATNState.StarBlockStart:
+                {
+                    s = new StarBlockStartState();
+                    break;
+                }
 
-				case ATNState.TokenStart:
-				{
-					s = new TokensStartState();
-					break;
-				}
+                case ATNState.TokenStart:
+                {
+                    s = new TokensStartState();
+                    break;
+                }
 
-				case ATNState.RuleStop:
-				{
-					s = new RuleStopState();
-					break;
-				}
+                case ATNState.RuleStop:
+                {
+                    s = new RuleStopState();
+                    break;
+                }
 
-				case ATNState.BlockEnd:
-				{
-					s = new BlockEndState();
-					break;
-				}
+                case ATNState.BlockEnd:
+                {
+                    s = new BlockEndState();
+                    break;
+                }
 
-				case ATNState.StarLoopBack:
-				{
-					s = new StarLoopbackState();
-					break;
-				}
+                case ATNState.StarLoopBack:
+                {
+                    s = new StarLoopbackState();
+                    break;
+                }
 
-				case ATNState.StarLoopEntry:
-				{
-					s = new StarLoopEntryState();
-					break;
-				}
+                case ATNState.StarLoopEntry:
+                {
+                    s = new StarLoopEntryState();
+                    break;
+                }
 
-				case ATNState.PlusLoopBack:
-				{
-					s = new PlusLoopbackState();
-					break;
-				}
+                case ATNState.PlusLoopBack:
+                {
+                    s = new PlusLoopbackState();
+                    break;
+                }
 
-				case ATNState.LoopEnd:
-				{
-					s = new LoopEndState();
-					break;
-				}
+                case ATNState.LoopEnd:
+                {
+                    s = new LoopEndState();
+                    break;
+                }
 
-				default:
-				{
-					string message = string.Format("The specified state type %d is not valid.", type);
-					throw new ArgumentException(message);
-				}
-			}
-			s.ruleIndex = ruleIndex;
-			return s;
-		}
-	}
+                default:
+                {
+                    string message = string.Format("The specified state type %d is not valid.", type);
+                    throw new ArgumentException(message);
+                }
+            }
+            s.ruleIndex = ruleIndex;
+            return s;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ATNState.cs b/Antlr4.Runtime/Atn/ATNState.cs
index ec21b38d6..356d880f8 100644
--- a/Antlr4.Runtime/Atn/ATNState.cs
+++ b/Antlr4.Runtime/Atn/ATNState.cs
@@ -35,270 +35,270 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>
-	/// The following images show the relation of states and
-	/// <see cref="transitions">transitions</see>
-	/// for various grammar constructs.
-	/// <ul>
-	/// <li>Solid edges marked with an &#0949; indicate a required
-	/// <see cref="EpsilonTransition">EpsilonTransition</see>
-	/// .</li>
-	/// <li>Dashed edges indicate locations where any transition derived from
-	/// <see cref="Transition">Transition</see>
-	/// might appear.</li>
-	/// <li>Dashed nodes are place holders for either a sequence of linked
-	/// <see cref="BasicState">BasicState</see>
-	/// 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>...</code>
-	/// support
-	/// any number of alternatives (one or more). Nodes without the
-	/// <code>...</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>(...)*</code>
-	/// </h3>
-	/// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
-	/// <h3>Greedy Positive Closure:
-	/// <code>(...)+</code>
-	/// </h3>
-	/// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
-	/// <h3>Greedy Optional:
-	/// <code>(...)?</code>
-	/// </h3>
-	/// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
-	/// <h2>Non-Greedy Loops</h2>
-	/// <h3>Non-Greedy Closure:
-	/// <code>(...)*?</code>
-	/// </h3>
-	/// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
-	/// <h3>Non-Greedy Positive Closure:
-	/// <code>(...)+?</code>
-	/// </h3>
-	/// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
-	/// <h3>Non-Greedy Optional:
-	/// <code>(...)??</code>
-	/// </h3>
-	/// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
-	/// </summary>
-	public abstract class ATNState
-	{
-		public const int InitialNumTransitions = 4;
+    /// <summary>
+    /// The following images show the relation of states and
+    /// <see cref="transitions">transitions</see>
+    /// for various grammar constructs.
+    /// <ul>
+    /// <li>Solid edges marked with an &#0949; indicate a required
+    /// <see cref="EpsilonTransition">EpsilonTransition</see>
+    /// .</li>
+    /// <li>Dashed edges indicate locations where any transition derived from
+    /// <see cref="Transition">Transition</see>
+    /// might appear.</li>
+    /// <li>Dashed nodes are place holders for either a sequence of linked
+    /// <see cref="BasicState">BasicState</see>
+    /// 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>...</code>
+    /// support
+    /// any number of alternatives (one or more). Nodes without the
+    /// <code>...</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>(...)*</code>
+    /// </h3>
+    /// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Greedy Positive Closure:
+    /// <code>(...)+</code>
+    /// </h3>
+    /// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Greedy Optional:
+    /// <code>(...)?</code>
+    /// </h3>
+    /// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+    /// <h2>Non-Greedy Loops</h2>
+    /// <h3>Non-Greedy Closure:
+    /// <code>(...)*?</code>
+    /// </h3>
+    /// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Non-Greedy Positive Closure:
+    /// <code>(...)+?</code>
+    /// </h3>
+    /// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+    /// <h3>Non-Greedy Optional:
+    /// <code>(...)??</code>
+    /// </h3>
+    /// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+    /// </summary>
+    public abstract class ATNState
+    {
+        public const int InitialNumTransitions = 4;
 
-		public const int InvalidType = 0;
+        public const int InvalidType = 0;
 
-		public const int Basic = 1;
+        public const int Basic = 1;
 
-		public const int RuleStart = 2;
+        public const int RuleStart = 2;
 
-		public const int BlockStart = 3;
+        public const int BlockStart = 3;
 
-		public const int PlusBlockStart = 4;
+        public const int PlusBlockStart = 4;
 
-		public const int StarBlockStart = 5;
+        public const int StarBlockStart = 5;
 
-		public const int TokenStart = 6;
+        public const int TokenStart = 6;
 
-		public const int RuleStop = 7;
+        public const int RuleStop = 7;
 
-		public const int BlockEnd = 8;
+        public const int BlockEnd = 8;
 
-		public const int StarLoopBack = 9;
+        public const int StarLoopBack = 9;
 
-		public const int StarLoopEntry = 10;
+        public const int StarLoopEntry = 10;
 
-		public const int PlusLoopBack = 11;
+        public const int PlusLoopBack = 11;
 
-		public const int LoopEnd = 12;
+        public const int LoopEnd = 12;
 
-		public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList
-			(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 static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList
+            (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;
+        public const int InvalidStateNumber = -1;
 
-		/// <summary>Which ATN are we in?</summary>
-		public ATN atn = null;
+        /// <summary>Which ATN are we in?</summary>
+        public ATN atn = null;
 
-		public int stateNumber = InvalidStateNumber;
+        public int stateNumber = InvalidStateNumber;
 
-		public int ruleIndex;
+        public int ruleIndex;
 
-		public bool epsilonOnlyTransitions = false;
+        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 IList<Antlr4.Runtime.Atn.Transition> transitions = new 
-			List<Antlr4.Runtime.Atn.Transition>(InitialNumTransitions);
+        /// <summary>Track the transitions emanating from this ATN state.</summary>
+        /// <remarks>Track the transitions emanating from this ATN state.</remarks>
+        protected internal readonly IList<Antlr4.Runtime.Atn.Transition> transitions = new 
+            List<Antlr4.Runtime.Atn.Transition>(InitialNumTransitions);
 
-		protected internal IList<Antlr4.Runtime.Atn.Transition> optimizedTransitions;
+        protected internal IList<Antlr4.Runtime.Atn.Transition> optimizedTransitions;
 
-		/// <summary>Used to cache lookahead during parsing, not used during construction</summary>
-		public IntervalSet nextTokenWithinRule;
+        /// <summary>Used to cache lookahead during parsing, not used during construction</summary>
+        public IntervalSet nextTokenWithinRule;
 
-		// constants for serialization
-		// at runtime, we don't have Rule objects
-		/// <summary>Gets the state number.</summary>
-		/// <remarks>Gets the state number.</remarks>
-		/// <returns>the state number</returns>
-		public int GetStateNumber()
-		{
-			return stateNumber;
-		}
+        // constants for serialization
+        // at runtime, we don't have Rule objects
+        /// <summary>Gets the state number.</summary>
+        /// <remarks>Gets the state number.</remarks>
+        /// <returns>the state number</returns>
+        public int GetStateNumber()
+        {
+            return stateNumber;
+        }
 
-		/// <summary>
-		/// For all states except
-		/// <see cref="RuleStopState">RuleStopState</see>
-		/// , this returns the state
-		/// number. Returns -1 for stop states.
-		/// </summary>
-		/// <returns>
-		/// -1 for
-		/// <see cref="RuleStopState">RuleStopState</see>
-		/// , otherwise the state number
-		/// </returns>
-		public virtual int GetNonStopStateNumber()
-		{
-			return GetStateNumber();
-		}
+        /// <summary>
+        /// For all states except
+        /// <see cref="RuleStopState">RuleStopState</see>
+        /// , this returns the state
+        /// number. Returns -1 for stop states.
+        /// </summary>
+        /// <returns>
+        /// -1 for
+        /// <see cref="RuleStopState">RuleStopState</see>
+        /// , otherwise the state number
+        /// </returns>
+        public virtual int GetNonStopStateNumber()
+        {
+            return GetStateNumber();
+        }
 
-		public override int GetHashCode()
-		{
-			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 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()
-		{
-			return false;
-		}
+        public virtual bool IsNonGreedyExitState()
+        {
+            return false;
+        }
 
-		public override string ToString()
-		{
-			return stateNumber.ToString();
-		}
+        public override string ToString()
+        {
+            return stateNumber.ToString();
+        }
 
-		public virtual Antlr4.Runtime.Atn.Transition[] GetTransitions()
-		{
-			return Sharpen.Collections.ToArray(transitions, new Antlr4.Runtime.Atn.Transition
-				[transitions.Count]);
-		}
+        public virtual Antlr4.Runtime.Atn.Transition[] GetTransitions()
+        {
+            return Sharpen.Collections.ToArray(transitions, new Antlr4.Runtime.Atn.Transition
+                [transitions.Count]);
+        }
 
-		public virtual int GetNumberOfTransitions()
-		{
-			return transitions.Count;
-		}
+        public virtual int GetNumberOfTransitions()
+        {
+            return transitions.Count;
+        }
 
-		public virtual void AddTransition(Antlr4.Runtime.Atn.Transition e)
-		{
-			if (transitions.IsEmpty())
-			{
-				epsilonOnlyTransitions = e.IsEpsilon;
-			}
-			else
-			{
-				if (epsilonOnlyTransitions != e.IsEpsilon)
-				{
-					System.Console.Error.Format("ATN state %d has both epsilon and non-epsilon transitions.\n"
-						, stateNumber);
-					epsilonOnlyTransitions = false;
-				}
-			}
-			transitions.AddItem(e);
-		}
+        public virtual void AddTransition(Antlr4.Runtime.Atn.Transition e)
+        {
+            if (transitions.IsEmpty())
+            {
+                epsilonOnlyTransitions = e.IsEpsilon;
+            }
+            else
+            {
+                if (epsilonOnlyTransitions != e.IsEpsilon)
+                {
+                    System.Console.Error.Format("ATN state %d has both epsilon and non-epsilon transitions.\n"
+                        , stateNumber);
+                    epsilonOnlyTransitions = false;
+                }
+            }
+            transitions.AddItem(e);
+        }
 
-		public virtual Antlr4.Runtime.Atn.Transition Transition(int i)
-		{
-			return transitions[i];
-		}
+        public virtual Antlr4.Runtime.Atn.Transition Transition(int i)
+        {
+            return transitions[i];
+        }
 
-		public virtual void SetTransition(int i, Antlr4.Runtime.Atn.Transition e)
-		{
-			transitions.Set(i, e);
-		}
+        public virtual void SetTransition(int i, Antlr4.Runtime.Atn.Transition e)
+        {
+            transitions.Set(i, e);
+        }
 
-		public virtual Antlr4.Runtime.Atn.Transition RemoveTransition(int index)
-		{
-			return transitions.Remove(index);
-		}
+        public virtual Antlr4.Runtime.Atn.Transition RemoveTransition(int index)
+        {
+            return transitions.Remove(index);
+        }
 
-		public abstract int GetStateType();
+        public abstract int GetStateType();
 
-		public bool OnlyHasEpsilonTransitions()
-		{
-			return epsilonOnlyTransitions;
-		}
+        public bool OnlyHasEpsilonTransitions()
+        {
+            return epsilonOnlyTransitions;
+        }
 
-		public virtual void SetRuleIndex(int ruleIndex)
-		{
-			this.ruleIndex = ruleIndex;
-		}
+        public virtual void SetRuleIndex(int ruleIndex)
+        {
+            this.ruleIndex = ruleIndex;
+        }
 
-		public virtual bool IsOptimized()
-		{
-			return optimizedTransitions != transitions;
-		}
+        public virtual bool IsOptimized()
+        {
+            return optimizedTransitions != transitions;
+        }
 
-		public virtual int GetNumberOfOptimizedTransitions()
-		{
-			return optimizedTransitions.Count;
-		}
+        public virtual int GetNumberOfOptimizedTransitions()
+        {
+            return optimizedTransitions.Count;
+        }
 
-		public virtual Antlr4.Runtime.Atn.Transition GetOptimizedTransition(int i)
-		{
-			return optimizedTransitions[i];
-		}
+        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.AddItem(e);
-		}
+        public virtual void AddOptimizedTransition(Antlr4.Runtime.Atn.Transition e)
+        {
+            if (!IsOptimized())
+            {
+                optimizedTransitions = new List<Antlr4.Runtime.Atn.Transition>();
+            }
+            optimizedTransitions.AddItem(e);
+        }
 
-		public virtual void SetOptimizedTransition(int i, Antlr4.Runtime.Atn.Transition e
-			)
-		{
-			if (!IsOptimized())
-			{
-				throw new InvalidOperationException();
-			}
-			optimizedTransitions.Set(i, e);
-		}
+        public virtual void SetOptimizedTransition(int i, Antlr4.Runtime.Atn.Transition e
+            )
+        {
+            if (!IsOptimized())
+            {
+                throw new InvalidOperationException();
+            }
+            optimizedTransitions.Set(i, e);
+        }
 
-		public virtual void RemoveOptimizedTransition(int i)
-		{
-			if (!IsOptimized())
-			{
-				throw new InvalidOperationException();
-			}
-			optimizedTransitions.Remove(i);
-		}
+        public virtual void RemoveOptimizedTransition(int i)
+        {
+            if (!IsOptimized())
+            {
+                throw new InvalidOperationException();
+            }
+            optimizedTransitions.Remove(i);
+        }
 
-		public ATNState()
-		{
-			optimizedTransitions = transitions;
-		}
-	}
+        public ATNState()
+        {
+            optimizedTransitions = transitions;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs b/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
index c8c7fe795..f921f0a79 100644
--- a/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
+++ b/Antlr4.Runtime/Atn/AbstractPredicateTransition.cs
@@ -32,11 +32,11 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public abstract class AbstractPredicateTransition : Transition
-	{
-		protected internal AbstractPredicateTransition(ATNState target) : base(target)
-		{
-		}
-	}
+    /// <author>Sam Harwell</author>
+    public abstract class AbstractPredicateTransition : Transition
+    {
+        protected internal AbstractPredicateTransition(ATNState target) : base(target)
+        {
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ActionTransition.cs b/Antlr4.Runtime/Atn/ActionTransition.cs
index 0668bbf73..12685c71d 100644
--- a/Antlr4.Runtime/Atn/ActionTransition.cs
+++ b/Antlr4.Runtime/Atn/ActionTransition.cs
@@ -32,53 +32,53 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class ActionTransition : Transition
-	{
-		public readonly int ruleIndex;
+    public sealed class ActionTransition : Transition
+    {
+        public readonly int ruleIndex;
 
-		public readonly int actionIndex;
+        public readonly int actionIndex;
 
-		public readonly bool isCtxDependent;
+        public readonly bool isCtxDependent;
 
-		public ActionTransition(ATNState target, int ruleIndex) : this(target, ruleIndex, 
-			-1, false)
-		{
-		}
+        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 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 int SerializationType
-		{
-			get
-			{
-				return Action;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Action;
+            }
+        }
 
-		public override bool IsEpsilon
-		{
-			get
-			{
-				return true;
-			}
-		}
+        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;
-		}
+        // 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;
-		}
-	}
+        public override string ToString()
+        {
+            return "action_" + ruleIndex + ":" + actionIndex;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ArrayPredictionContext.cs b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
index 9142be4a4..3c4cdbb06 100644
--- a/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/ArrayPredictionContext.cs
@@ -35,249 +35,249 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public class ArrayPredictionContext : PredictionContext
-	{
-		[NotNull]
-		public readonly PredictionContext[] parents;
+    public class ArrayPredictionContext : PredictionContext
+    {
+        [NotNull]
+        public readonly PredictionContext[] parents;
 
-		[NotNull]
-		public readonly int[] returnStates;
+        [NotNull]
+        public readonly int[] returnStates;
 
-		internal ArrayPredictionContext(PredictionContext[] parents, int[] returnStates) : 
-			base(CalculateHashCode(CalculateParentHashCode(parents), CalculateReturnStatesHashCode
-			(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) : 
+            base(CalculateHashCode(CalculateParentHashCode(parents), CalculateReturnStatesHashCode
+            (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;
-		}
+        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 PredictionContext GetParent(int index)
+        {
+            return parents[index];
+        }
 
-		public override int GetReturnState(int index)
-		{
-			return returnStates[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 FindReturnState(int returnState)
+        {
+            return System.Array.BinarySearch(returnStates, returnState);
+        }
 
-		public override int Size
-		{
-			get
-			{
-				return returnStates.Length;
-			}
-		}
+        public override int Size
+        {
+            get
+            {
+                return returnStates.Length;
+            }
+        }
 
-		public override bool IsEmpty
-		{
-			get
-			{
-				return false;
-			}
-		}
+        public override bool IsEmpty
+        {
+            get
+            {
+                return false;
+            }
+        }
 
-		public override bool HasEmpty
-		{
-			get
-			{
-				return returnStates[returnStates.Length - 1] == EmptyFullStateKey;
-			}
-		}
+        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 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);
-			}
-		}
+        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());
-		}
+        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 = visited.Get(context);
-			if (result == null)
-			{
-				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.Put(context, result);
-			}
-			return result;
-		}
+        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 = visited.Get(context);
+            if (result == null)
+            {
+                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.Put(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
-				>());
-		}
+        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, ICollection<
-			PredictionContextCache.IdentityCommutativePredictionContextOperands> visited)
-		{
-			IDeque<PredictionContext> selfWorkList = new ArrayDeque<PredictionContext>();
-			IDeque<PredictionContext> otherWorkList = new ArrayDeque<PredictionContext>();
-			selfWorkList.Push(this);
-			otherWorkList.Push(other);
-			while (!selfWorkList.IsEmpty())
-			{
-				PredictionContextCache.IdentityCommutativePredictionContextOperands operands = new 
-					PredictionContextCache.IdentityCommutativePredictionContextOperands(selfWorkList
-					.Pop(), otherWorkList.Pop());
-				if (!visited.AddItem(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;
-		}
-	}
+        private bool Equals(Antlr4.Runtime.Atn.ArrayPredictionContext other, ICollection<
+            PredictionContextCache.IdentityCommutativePredictionContextOperands> visited)
+        {
+            IDeque<PredictionContext> selfWorkList = new ArrayDeque<PredictionContext>();
+            IDeque<PredictionContext> otherWorkList = new ArrayDeque<PredictionContext>();
+            selfWorkList.Push(this);
+            otherWorkList.Push(other);
+            while (!selfWorkList.IsEmpty())
+            {
+                PredictionContextCache.IdentityCommutativePredictionContextOperands operands = new 
+                    PredictionContextCache.IdentityCommutativePredictionContextOperands(selfWorkList
+                    .Pop(), otherWorkList.Pop());
+                if (!visited.AddItem(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/Antlr4.Runtime/Atn/AtomTransition.cs b/Antlr4.Runtime/Atn/AtomTransition.cs
index 826db46dd..58fbbeffb 100644
--- a/Antlr4.Runtime/Atn/AtomTransition.cs
+++ b/Antlr4.Runtime/Atn/AtomTransition.cs
@@ -33,43 +33,43 @@ using 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 label;
+    /// <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 label;
 
-		public AtomTransition(ATNState target, int label) : base(target)
-		{
-			this.label = label;
-		}
+        public AtomTransition(ATNState target, int label) : base(target)
+        {
+            this.label = label;
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return Atom;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Atom;
+            }
+        }
 
-		public override IntervalSet Label
-		{
-			get
-			{
-				return IntervalSet.Of(label);
-			}
-		}
+        public override IntervalSet Label
+        {
+            get
+            {
+                return IntervalSet.Of(label);
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return label == symbol;
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return label == symbol;
+        }
 
-		[NotNull]
-		public override string ToString()
-		{
-			return label.ToString();
-		}
-	}
+        [NotNull]
+        public override string ToString()
+        {
+            return label.ToString();
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/BasicBlockStartState.cs b/Antlr4.Runtime/Atn/BasicBlockStartState.cs
index 8be4d5591..f29585fdb 100644
--- a/Antlr4.Runtime/Atn/BasicBlockStartState.cs
+++ b/Antlr4.Runtime/Atn/BasicBlockStartState.cs
@@ -32,12 +32,12 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public sealed class BasicBlockStartState : BlockStartState
-	{
-		public override int GetStateType()
-		{
-			return BlockStart;
-		}
-	}
+    /// <author>Sam Harwell</author>
+    public sealed class BasicBlockStartState : BlockStartState
+    {
+        public override int GetStateType()
+        {
+            return BlockStart;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/BasicState.cs b/Antlr4.Runtime/Atn/BasicState.cs
index c405eab44..9f44ca4cd 100644
--- a/Antlr4.Runtime/Atn/BasicState.cs
+++ b/Antlr4.Runtime/Atn/BasicState.cs
@@ -32,12 +32,12 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public sealed class BasicState : ATNState
-	{
-		public override int GetStateType()
-		{
-			return Basic;
-		}
-	}
+    /// <author>Sam Harwell</author>
+    public sealed class BasicState : ATNState
+    {
+        public override int GetStateType()
+        {
+            return Basic;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/BlockEndState.cs b/Antlr4.Runtime/Atn/BlockEndState.cs
index 9056200ed..03b3a81af 100644
--- a/Antlr4.Runtime/Atn/BlockEndState.cs
+++ b/Antlr4.Runtime/Atn/BlockEndState.cs
@@ -32,18 +32,18 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>
-	/// Terminal node of a simple
-	/// <code>(a|b|c)</code>
-	/// block.
-	/// </summary>
-	public sealed class BlockEndState : ATNState
-	{
-		public BlockStartState startState;
+    /// <summary>
+    /// Terminal node of a simple
+    /// <code>(a|b|c)</code>
+    /// block.
+    /// </summary>
+    public sealed class BlockEndState : ATNState
+    {
+        public BlockStartState startState;
 
-		public override int GetStateType()
-		{
-			return BlockEnd;
-		}
-	}
+        public override int GetStateType()
+        {
+            return BlockEnd;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/BlockStartState.cs b/Antlr4.Runtime/Atn/BlockStartState.cs
index 99332d8b1..72e5e19eb 100644
--- a/Antlr4.Runtime/Atn/BlockStartState.cs
+++ b/Antlr4.Runtime/Atn/BlockStartState.cs
@@ -32,13 +32,13 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>
-	/// The start of a regular
-	/// <code>(...)</code>
-	/// block.
-	/// </summary>
-	public abstract class BlockStartState : DecisionState
-	{
-		public BlockEndState endState;
-	}
+    /// <summary>
+    /// The start of a regular
+    /// <code>(...)</code>
+    /// block.
+    /// </summary>
+    public abstract class BlockStartState : DecisionState
+    {
+        public BlockEndState endState;
+    }
 }
diff --git a/Antlr4.Runtime/Atn/DecisionState.cs b/Antlr4.Runtime/Atn/DecisionState.cs
index 45594319c..885c630c6 100644
--- a/Antlr4.Runtime/Atn/DecisionState.cs
+++ b/Antlr4.Runtime/Atn/DecisionState.cs
@@ -32,12 +32,12 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public abstract class DecisionState : ATNState
-	{
-		public int decision = -1;
+    public abstract class DecisionState : ATNState
+    {
+        public int decision = -1;
 
-		public bool nonGreedy;
+        public bool nonGreedy;
 
-		public bool sll;
-	}
+        public bool sll;
+    }
 }
diff --git a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
index 86761986a..5e5f38046 100644
--- a/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/EmptyPredictionContext.cs
@@ -34,103 +34,103 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class EmptyPredictionContext : PredictionContext
-	{
-		public static readonly Antlr4.Runtime.Atn.EmptyPredictionContext LocalContext = new 
-			Antlr4.Runtime.Atn.EmptyPredictionContext(false);
+    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);
+        public static readonly Antlr4.Runtime.Atn.EmptyPredictionContext FullContext = new 
+            Antlr4.Runtime.Atn.EmptyPredictionContext(true);
 
-		private readonly bool fullContext;
+        private readonly bool fullContext;
 
-		private EmptyPredictionContext(bool fullContext) : base(CalculateHashCode(CalculateEmptyParentHashCode
-			(), CalculateEmptyReturnStateHashCode()))
-		{
-			this.fullContext = fullContext;
-		}
+        private EmptyPredictionContext(bool fullContext) : base(CalculateHashCode(CalculateEmptyParentHashCode
+            (), CalculateEmptyReturnStateHashCode()))
+        {
+            this.fullContext = fullContext;
+        }
 
-		public bool IsFullContext()
-		{
-			return fullContext;
-		}
+        public bool IsFullContext()
+        {
+            return fullContext;
+        }
 
-		protected internal override PredictionContext AddEmptyContext()
-		{
-			return this;
-		}
+        protected internal override PredictionContext AddEmptyContext()
+        {
+            return this;
+        }
 
-		protected internal override PredictionContext RemoveEmptyContext()
-		{
-			throw new NotSupportedException("Cannot remove the empty context from itself.");
-		}
+        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 PredictionContext GetParent(int index)
+        {
+            throw new ArgumentOutOfRangeException();
+        }
 
-		public override int GetReturnState(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 FindReturnState(int returnState)
+        {
+            return -1;
+        }
 
-		public override int Size
-		{
-			get
-			{
-				return 0;
-			}
-		}
+        public override int Size
+        {
+            get
+            {
+                return 0;
+            }
+        }
 
-		public override PredictionContext AppendContext(int returnContext, PredictionContextCache
-			 contextCache)
-		{
-			return contextCache.GetChild(this, returnContext);
-		}
+        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 PredictionContext AppendContext(PredictionContext suffix, PredictionContextCache
+             contextCache)
+        {
+            return suffix;
+        }
 
-		public override bool IsEmpty
-		{
-			get
-			{
-				return true;
-			}
-		}
+        public override bool IsEmpty
+        {
+            get
+            {
+                return true;
+            }
+        }
 
-		public override bool HasEmpty
-		{
-			get
-			{
-				return true;
-			}
-		}
+        public override bool HasEmpty
+        {
+            get
+            {
+                return true;
+            }
+        }
 
-		public override bool Equals(object o)
-		{
-			return this == o;
-		}
+        public override bool Equals(object o)
+        {
+            return this == o;
+        }
 
-		public override string[] ToStrings<_T0>(Recognizer<_T0> recognizer, int currentState
-			)
-		{
-			return new string[] { "[]" };
-		}
+        public override string[] ToStrings<_T0>(Recognizer<_T0> recognizer, int currentState
+            )
+        {
+            return new string[] { "[]" };
+        }
 
-		public override string[] ToStrings<_T0>(Recognizer<_T0> recognizer, PredictionContext
-			 stop, int currentState)
-		{
-			return new string[] { "[]" };
-		}
-	}
+        public override string[] ToStrings<_T0>(Recognizer<_T0> recognizer, PredictionContext
+             stop, int currentState)
+        {
+            return new string[] { "[]" };
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/EpsilonTransition.cs b/Antlr4.Runtime/Atn/EpsilonTransition.cs
index d5c3fcd65..2affa3755 100644
--- a/Antlr4.Runtime/Atn/EpsilonTransition.cs
+++ b/Antlr4.Runtime/Atn/EpsilonTransition.cs
@@ -33,37 +33,37 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class EpsilonTransition : Transition
-	{
-		protected internal EpsilonTransition(ATNState target) : base(target)
-		{
-		}
+    public sealed class EpsilonTransition : Transition
+    {
+        protected internal EpsilonTransition(ATNState target) : base(target)
+        {
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return Epsilon;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Epsilon;
+            }
+        }
 
-		public override bool IsEpsilon
-		{
-			get
-			{
-				return true;
-			}
-		}
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return false;
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
 
-		[NotNull]
-		public override string ToString()
-		{
-			return "epsilon";
-		}
-	}
+        [NotNull]
+        public override string ToString()
+        {
+            return "epsilon";
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/LL1Analyzer.cs b/Antlr4.Runtime/Atn/LL1Analyzer.cs
index 926b868bd..94f6a23c6 100644
--- a/Antlr4.Runtime/Atn/LL1Analyzer.cs
+++ b/Antlr4.Runtime/Atn/LL1Analyzer.cs
@@ -35,198 +35,198 @@ using 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 seeThruPreds==false.
-		/// </summary>
-		/// <remarks>
-		/// Special value added to the lookahead sets to indicate that we hit
-		/// a predicate during analysis if seeThruPreds==false.
-		/// </remarks>
-		public const int HitPred = IToken.InvalidType;
+    public class LL1Analyzer
+    {
+        /// <summary>
+        /// Special value added to the lookahead sets to indicate that we hit
+        /// a predicate during analysis if seeThruPreds==false.
+        /// </summary>
+        /// <remarks>
+        /// Special value added to the lookahead sets to indicate that we hit
+        /// a predicate during analysis if seeThruPreds==false.
+        /// </remarks>
+        public const int HitPred = IToken.InvalidType;
 
-		[NotNull]
-		public readonly ATN atn;
+        [NotNull]
+        public readonly ATN atn;
 
-		public LL1Analyzer(ATN atn)
-		{
-			this.atn = atn;
-		}
+        public LL1Analyzer(ATN atn)
+        {
+            this.atn = atn;
+        }
 
-		/// <summary>
-		/// From an ATN state,
-		/// <code>s</code>
-		/// , find the set of all labels reachable from
-		/// <code>s</code>
-		/// at depth k. Only for DecisionStates.
-		/// </summary>
-		[Nullable]
-		public virtual IntervalSet[] GetDecisionLookahead(ATNState s)
-		{
-			//		System.out.println("LOOK("+s.stateNumber+")");
-			if (s == null)
-			{
-				return null;
-			}
-			IntervalSet[] look = new IntervalSet[s.GetNumberOfTransitions() + 1];
-			for (int alt = 1; alt <= s.GetNumberOfTransitions(); alt++)
-			{
-				look[alt] = new IntervalSet();
-				ICollection<ATNConfig> lookBusy = new HashSet<ATNConfig>();
-				bool seeThruPreds = false;
-				// fail to get lookahead upon pred
-				Look(s.Transition(alt - 1).target, PredictionContext.EmptyFull, look[alt], lookBusy
-					, seeThruPreds, false);
-				// Wipe out lookahead for this alternative if we found nothing
-				// or we had a predicate when we !seeThruPreds
-				if (look[alt].Size() == 0 || look[alt].Contains(HitPred))
-				{
-					look[alt] = null;
-				}
-			}
-			return look;
-		}
+        /// <summary>
+        /// From an ATN state,
+        /// <code>s</code>
+        /// , find the set of all labels reachable from
+        /// <code>s</code>
+        /// at depth k. Only for DecisionStates.
+        /// </summary>
+        [Nullable]
+        public virtual IntervalSet[] GetDecisionLookahead(ATNState s)
+        {
+            //		System.out.println("LOOK("+s.stateNumber+")");
+            if (s == null)
+            {
+                return null;
+            }
+            IntervalSet[] look = new IntervalSet[s.GetNumberOfTransitions() + 1];
+            for (int alt = 1; alt <= s.GetNumberOfTransitions(); alt++)
+            {
+                look[alt] = new IntervalSet();
+                ICollection<ATNConfig> lookBusy = new HashSet<ATNConfig>();
+                bool seeThruPreds = false;
+                // fail to get lookahead upon pred
+                Look(s.Transition(alt - 1).target, PredictionContext.EmptyFull, look[alt], lookBusy
+                    , seeThruPreds, false);
+                // Wipe out lookahead for this alternative if we found nothing
+                // or we had a predicate when we !seeThruPreds
+                if (look[alt].Size() == 0 || look[alt].Contains(HitPred))
+                {
+                    look[alt] = null;
+                }
+            }
+            return look;
+        }
 
-		/// <summary>
-		/// Get lookahead, using
-		/// <code>ctx</code>
-		/// if we reach end of rule. If
-		/// <code>ctx</code>
-		/// is
-		/// <code>PredictionContext#EMPTY_LOCAL</code>
-		/// or
-		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
-		/// , don't chase FOLLOW. If
-		/// <code>ctx</code>
-		/// is
-		/// <code>PredictionContext#EMPTY_LOCAL</code>
-		/// ,
-		/// <see cref="Antlr4.Runtime.IToken.Epsilon">EPSILON</see>
-		/// is in set if we can reach end of rule. If
-		/// <code>ctx</code>
-		/// is
-		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
-		/// ,
-		/// <see cref="Antlr4.Runtime.IIntStream.Eof">EOF</see>
-		/// is in set
-		/// if we can reach end of rule.
-		/// </summary>
-		[NotNull]
-		public virtual IntervalSet Look(ATNState s, PredictionContext ctx)
-		{
-			Args.NotNull("ctx", ctx);
-			IntervalSet r = new IntervalSet();
-			bool seeThruPreds = true;
-			// ignore preds; get all lookahead
-			Look(s, ctx, r, new HashSet<ATNConfig>(), seeThruPreds, true);
-			return r;
-		}
+        /// <summary>
+        /// Get lookahead, using
+        /// <code>ctx</code>
+        /// if we reach end of rule. If
+        /// <code>ctx</code>
+        /// is
+        /// <code>PredictionContext#EMPTY_LOCAL</code>
+        /// or
+        /// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
+        /// , don't chase FOLLOW. If
+        /// <code>ctx</code>
+        /// is
+        /// <code>PredictionContext#EMPTY_LOCAL</code>
+        /// ,
+        /// <see cref="Antlr4.Runtime.IToken.Epsilon">EPSILON</see>
+        /// is in set if we can reach end of rule. If
+        /// <code>ctx</code>
+        /// is
+        /// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
+        /// ,
+        /// <see cref="Antlr4.Runtime.IIntStream.Eof">EOF</see>
+        /// is in set
+        /// if we can reach end of rule.
+        /// </summary>
+        [NotNull]
+        public virtual IntervalSet Look(ATNState s, PredictionContext ctx)
+        {
+            Args.NotNull("ctx", ctx);
+            IntervalSet r = new IntervalSet();
+            bool seeThruPreds = true;
+            // ignore preds; get all lookahead
+            Look(s, ctx, r, new HashSet<ATNConfig>(), seeThruPreds, true);
+            return r;
+        }
 
-		/// <summary>Compute set of tokens that can come next.</summary>
-		/// <remarks>
-		/// Compute set of tokens that can come next. If the context is
-		/// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
-		/// ,
-		/// then we don't go anywhere when we hit the end of the rule. We have
-		/// the correct set.  If the context is
-		/// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
-		/// ,
-		/// that means that we did not want any tokens following this rule--just the
-		/// tokens that could be found within this rule. Add EPSILON to the set
-		/// indicating we reached the end of the ruled out having to match a token.
-		/// </remarks>
-		protected internal virtual void Look(ATNState s, PredictionContext ctx, IntervalSet
-			 look, ICollection<ATNConfig> lookBusy, bool seeThruPreds, bool addEOF)
-		{
-			//		System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx);
-			ATNConfig c = ATNConfig.Create(s, 0, ctx);
-			if (!lookBusy.AddItem(c))
-			{
-				return;
-			}
-			if (s is RuleStopState)
-			{
-				if (PredictionContext.IsEmptyLocal(ctx))
-				{
-					look.Add(IToken.Epsilon);
-					return;
-				}
-				else
-				{
-					if (ctx.IsEmpty && addEOF)
-					{
-						look.Add(IToken.Eof);
-						return;
-					}
-				}
-				for (int i = 0; i < ctx.Size; i++)
-				{
-					if (ctx.GetReturnState(i) != PredictionContext.EmptyFullStateKey)
-					{
-						ATNState returnState = atn.states[ctx.GetReturnState(i)];
-						//			System.out.println("popping back to "+retState);
-						for (int j = 0; j < ctx.Size; j++)
-						{
-							Look(returnState, ctx.GetParent(j), look, lookBusy, seeThruPreds, addEOF);
-						}
-						return;
-					}
-				}
-			}
-			int n = s.GetNumberOfTransitions();
-			for (int i_1 = 0; i_1 < n; i_1++)
-			{
-				Transition t = s.Transition(i_1);
-				if (t.GetType() == typeof(RuleTransition))
-				{
-					PredictionContext newContext = ctx.GetChild(((RuleTransition)t).followState.stateNumber
-						);
-					Look(t.target, newContext, look, lookBusy, seeThruPreds, addEOF);
-				}
-				else
-				{
-					if (t is AbstractPredicateTransition)
-					{
-						if (seeThruPreds)
-						{
-							Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
-						}
-						else
-						{
-							look.Add(HitPred);
-						}
-					}
-					else
-					{
-						if (t.IsEpsilon)
-						{
-							Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
-						}
-						else
-						{
-							if (t.GetType() == typeof(WildcardTransition))
-							{
-								look.AddAll(IntervalSet.Of(IToken.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(IToken.MinUserTokenType, atn.maxTokenType));
-									}
-									look.AddAll(set);
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
+        /// <summary>Compute set of tokens that can come next.</summary>
+        /// <remarks>
+        /// Compute set of tokens that can come next. If the context is
+        /// <see cref="PredictionContext.EmptyFull">PredictionContext.EmptyFull</see>
+        /// ,
+        /// then we don't go anywhere when we hit the end of the rule. We have
+        /// the correct set.  If the context is
+        /// <see cref="PredictionContext.EmptyLocal">PredictionContext.EmptyLocal</see>
+        /// ,
+        /// that means that we did not want any tokens following this rule--just the
+        /// tokens that could be found within this rule. Add EPSILON to the set
+        /// indicating we reached the end of the ruled out having to match a token.
+        /// </remarks>
+        protected internal virtual void Look(ATNState s, PredictionContext ctx, IntervalSet
+             look, ICollection<ATNConfig> lookBusy, bool seeThruPreds, bool addEOF)
+        {
+            //		System.out.println("_LOOK("+s.stateNumber+", ctx="+ctx);
+            ATNConfig c = ATNConfig.Create(s, 0, ctx);
+            if (!lookBusy.AddItem(c))
+            {
+                return;
+            }
+            if (s is RuleStopState)
+            {
+                if (PredictionContext.IsEmptyLocal(ctx))
+                {
+                    look.Add(IToken.Epsilon);
+                    return;
+                }
+                else
+                {
+                    if (ctx.IsEmpty && addEOF)
+                    {
+                        look.Add(IToken.Eof);
+                        return;
+                    }
+                }
+                for (int i = 0; i < ctx.Size; i++)
+                {
+                    if (ctx.GetReturnState(i) != PredictionContext.EmptyFullStateKey)
+                    {
+                        ATNState returnState = atn.states[ctx.GetReturnState(i)];
+                        //			System.out.println("popping back to "+retState);
+                        for (int j = 0; j < ctx.Size; j++)
+                        {
+                            Look(returnState, ctx.GetParent(j), look, lookBusy, seeThruPreds, addEOF);
+                        }
+                        return;
+                    }
+                }
+            }
+            int n = s.GetNumberOfTransitions();
+            for (int i_1 = 0; i_1 < n; i_1++)
+            {
+                Transition t = s.Transition(i_1);
+                if (t.GetType() == typeof(RuleTransition))
+                {
+                    PredictionContext newContext = ctx.GetChild(((RuleTransition)t).followState.stateNumber
+                        );
+                    Look(t.target, newContext, look, lookBusy, seeThruPreds, addEOF);
+                }
+                else
+                {
+                    if (t is AbstractPredicateTransition)
+                    {
+                        if (seeThruPreds)
+                        {
+                            Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
+                        }
+                        else
+                        {
+                            look.Add(HitPred);
+                        }
+                    }
+                    else
+                    {
+                        if (t.IsEpsilon)
+                        {
+                            Look(t.target, ctx, look, lookBusy, seeThruPreds, addEOF);
+                        }
+                        else
+                        {
+                            if (t.GetType() == typeof(WildcardTransition))
+                            {
+                                look.AddAll(IntervalSet.Of(IToken.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(IToken.MinUserTokenType, atn.maxTokenType));
+                                    }
+                                    look.AddAll(set);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/LexerATNSimulator.cs b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
index 72656715d..86c21dcd9 100644
--- a/Antlr4.Runtime/Atn/LexerATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/LexerATNSimulator.cs
@@ -36,706 +36,706 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>"dup" of ParserInterpreter</summary>
-	public class LexerATNSimulator : ATNSimulator
-	{
-		public const bool debug = false;
+    /// <summary>"dup" of ParserInterpreter</summary>
+    public class LexerATNSimulator : ATNSimulator
+    {
+        public const bool debug = false;
 
-		public const bool dfa_debug = false;
+        public const bool dfa_debug = false;
 
-		public const int MinDfaEdge = 0;
+        public const int MinDfaEdge = 0;
 
-		public const int MaxDfaEdge = 127;
+        public const int MaxDfaEdge = 127;
 
-		public bool optimize_tail_calls = true;
+        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()">Antlr4.Runtime.IIntStream.Mark()</see>
-		/// 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.
-		/// </summary>
-		protected internal class SimState
-		{
-			protected internal int index = -1;
+        /// <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()">Antlr4.Runtime.IIntStream.Mark()</see>
+        /// 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.
+        /// </summary>
+        protected internal class SimState
+        {
+            protected internal int index = -1;
 
-			protected internal int line = 0;
+            protected internal int line = 0;
 
-			protected internal int charPos = -1;
+            protected internal int charPos = -1;
 
-			protected internal DFAState dfaState;
+            protected internal DFAState dfaState;
 
-			// forces unicode to stay in ATN
-			protected internal virtual void Reset()
-			{
-				index = -1;
-				line = 0;
-				charPos = -1;
-				dfaState = null;
-			}
-		}
+            // 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;
+        [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>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>
-		protected internal int line = 1;
+        /// <summary>line number 1..n within the input</summary>
+        protected internal 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;
+        /// <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;
+        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
-			();
+        /// <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 static int match_calls = 0;
 
-		public LexerATNSimulator(ATN atn) : this(null, atn)
-		{
-		}
+        public LexerATNSimulator(ATN atn) : this(null, atn)
+        {
+        }
 
-		public LexerATNSimulator(Lexer recog, ATN atn) : base(atn)
-		{
-			this.recog = recog;
-		}
+        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 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 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;
-		}
+        public override void Reset()
+        {
+            prevAccept.Reset();
+            startIndex = -1;
+            line = 1;
+            charPositionInLine = 0;
+            mode = Lexer.DefaultMode;
+        }
 
-		// only called from test code from outside
-		protected internal virtual int MatchATN(ICharStream input)
-		{
-			ATNState startState = atn.modeToStartState[mode];
-			int old_mode = 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;
-		}
+        // only called from test code from outside
+        protected internal virtual int MatchATN(ICharStream input)
+        {
+            ATNState startState = atn.modeToStartState[mode];
+            int old_mode = 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);
-			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.
-				ATNConfigSet closure = s.configs;
-				DFAState target = null;
-				target = s.GetTarget(t);
-				if (target == Error)
-				{
-					break;
-				}
-				if (debug && target != null)
-				{
-					System.Console.Out.WriteLine("reuse state " + s.stateNumber + " edge to " + target
-						.stateNumber);
-				}
-				if (target == null)
-				{
-					ATNConfigSet reach = new OrderedATNConfigSet();
-					// if we don't find an existing DFA state
-					// Fill reach starting from closure, following t transitions
-					GetReachableConfigSet(input, closure, reach, t);
-					if (reach.IsEmpty())
-					{
-						// we got nowhere on t from s
-						// we reached state associated with closure for sure, so
-						// make sure it's defined. worst case, we define s0 from
-						// start state configs.
-						DFAState from = s != null ? s : AddDFAState(closure);
-						// we got nowhere on t, don't throw out this knowledge; it'd
-						// cause a failover from DFA later.
-						AddDFAEdge(from, t, Error);
-						break;
-					}
-					// stop when we can't match any more char
-					// Add an edge from s to target DFA found/created for reach
-					target = AddDFAEdge(s, t, reach);
-				}
-				if (target.isAcceptState)
-				{
-					CaptureSimState(prevAccept, input, target);
-					if (t == IIntStream.Eof)
-					{
-						break;
-					}
-				}
-				if (t != IIntStream.Eof)
-				{
-					Consume(input);
-					t = input.La(1);
-				}
-				s = target;
-			}
-			// flip; current DFA target becomes new src/from state
-			return FailOrAccept(prevAccept, input, s.configs, t);
-		}
+        protected internal virtual int ExecATN(ICharStream input, DFAState ds0)
+        {
+            //System.out.println("enter exec index "+input.index()+" from "+ds0.configs);
+            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.
+                ATNConfigSet closure = s.configs;
+                DFAState target = null;
+                target = s.GetTarget(t);
+                if (target == Error)
+                {
+                    break;
+                }
+                if (debug && target != null)
+                {
+                    System.Console.Out.WriteLine("reuse state " + s.stateNumber + " edge to " + target
+                        .stateNumber);
+                }
+                if (target == null)
+                {
+                    ATNConfigSet reach = new OrderedATNConfigSet();
+                    // if we don't find an existing DFA state
+                    // Fill reach starting from closure, following t transitions
+                    GetReachableConfigSet(input, closure, reach, t);
+                    if (reach.IsEmpty())
+                    {
+                        // we got nowhere on t from s
+                        // we reached state associated with closure for sure, so
+                        // make sure it's defined. worst case, we define s0 from
+                        // start state configs.
+                        DFAState from = s != null ? s : AddDFAState(closure);
+                        // we got nowhere on t, don't throw out this knowledge; it'd
+                        // cause a failover from DFA later.
+                        AddDFAEdge(from, t, Error);
+                        break;
+                    }
+                    // stop when we can't match any more char
+                    // Add an edge from s to target DFA found/created for reach
+                    target = AddDFAEdge(s, t, reach);
+                }
+                if (target.isAcceptState)
+                {
+                    CaptureSimState(prevAccept, input, target);
+                    if (t == IIntStream.Eof)
+                    {
+                        break;
+                    }
+                }
+                if (t != IIntStream.Eof)
+                {
+                    Consume(input);
+                    t = input.La(1);
+                }
+                s = target;
+            }
+            // flip; current DFA target becomes new src/from state
+            return FailOrAccept(prevAccept, input, s.configs, t);
+        }
 
-		protected internal virtual int FailOrAccept(LexerATNSimulator.SimState prevAccept
-			, ICharStream input, ATNConfigSet reach, int t)
-		{
-			if (prevAccept.dfaState != null)
-			{
-				int ruleIndex = prevAccept.dfaState.lexerRuleIndex;
-				int actionIndex = prevAccept.dfaState.lexerActionIndex;
-				Accept(input, ruleIndex, actionIndex, prevAccept.index, prevAccept.line, prevAccept
-					.charPos);
-				return prevAccept.dfaState.prediction;
-			}
-			else
-			{
-				// if no accept and EOF is first char, return EOF
-				if (t == IIntStream.Eof && input.Index == startIndex)
-				{
-					return IToken.Eof;
-				}
-				throw new LexerNoViableAltException(recog, input, startIndex, reach);
-			}
-		}
+        protected internal virtual int FailOrAccept(LexerATNSimulator.SimState prevAccept
+            , ICharStream input, ATNConfigSet reach, int t)
+        {
+            if (prevAccept.dfaState != null)
+            {
+                int ruleIndex = prevAccept.dfaState.lexerRuleIndex;
+                int actionIndex = prevAccept.dfaState.lexerActionIndex;
+                Accept(input, ruleIndex, actionIndex, prevAccept.index, prevAccept.line, prevAccept
+                    .charPos);
+                return prevAccept.dfaState.prediction;
+            }
+            else
+            {
+                // if no accept and EOF is first char, return EOF
+                if (t == IIntStream.Eof && input.Index == startIndex)
+                {
+                    return IToken.Eof;
+                }
+                throw new LexerNoViableAltException(recog, input, startIndex, reach);
+            }
+        }
 
-		/// <summary>
-		/// Given a starting configuration set, figure out all ATN configurations
-		/// we can reach upon input
-		/// <code>t</code>
-		/// . Parameter
-		/// <code>reach</code>
-		/// 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)
-			{
-				if (c.GetAlt() == skipAlt)
-				{
-					continue;
-				}
-				int n = c.GetState().GetNumberOfOptimizedTransitions();
-				for (int ti = 0; ti < n; ti++)
-				{
-					// for each optimized transition
-					Transition trans = c.GetState().GetOptimizedTransition(ti);
-					ATNState target = GetReachableTarget(trans, t);
-					if (target != null)
-					{
-						if (Closure(input, c.Transform(target), reach, true))
-						{
-							// any remaining configs for this alt have a lower priority than
-							// the one that just reached an accept state.
-							skipAlt = c.GetAlt();
-							break;
-						}
-					}
-				}
-			}
-		}
+        /// <summary>
+        /// Given a starting configuration set, figure out all ATN configurations
+        /// we can reach upon input
+        /// <code>t</code>
+        /// . Parameter
+        /// <code>reach</code>
+        /// 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)
+            {
+                if (c.GetAlt() == skipAlt)
+                {
+                    continue;
+                }
+                int n = c.GetState().GetNumberOfOptimizedTransitions();
+                for (int ti = 0; ti < n; ti++)
+                {
+                    // for each optimized transition
+                    Transition trans = c.GetState().GetOptimizedTransition(ti);
+                    ATNState target = GetReachableTarget(trans, t);
+                    if (target != null)
+                    {
+                        if (Closure(input, c.Transform(target), reach, true))
+                        {
+                            // any remaining configs for this alt have a lower priority than
+                            // the one that just reached an accept state.
+                            skipAlt = c.GetAlt();
+                            break;
+                        }
+                    }
+                }
+            }
+        }
 
-		protected internal virtual void Accept(ICharStream input, int ruleIndex, int actionIndex
-			, int index, int line, int charPos)
-		{
-			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) != IIntStream.Eof)
-			{
-				Consume(input);
-			}
-		}
+        protected internal virtual void Accept(ICharStream input, int ruleIndex, int actionIndex
+            , int index, int line, int charPos)
+        {
+            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) != IIntStream.Eof)
+            {
+                Consume(input);
+            }
+        }
 
-		[Nullable]
-		public virtual ATNState GetReachableTarget(Transition trans, int t)
-		{
-			if (trans.Matches(t, Lexer.MinCharValue, Lexer.MaxCharValue))
-			{
-				return trans.target;
-			}
-			return null;
-		}
+        [Nullable]
+        public virtual ATNState GetReachableTarget(Transition trans, int t)
+        {
+            if (trans.Matches(t, Lexer.MinCharValue, Lexer.MaxCharValue))
+            {
+                return trans.target;
+            }
+            return null;
+        }
 
-		[NotNull]
-		protected internal virtual ATNConfigSet ComputeStartState(ICharStream input, ATNState
-			 p)
-		{
-			PredictionContext initialContext = PredictionContext.EmptyFull;
-			ATNConfigSet configs = new OrderedATNConfigSet();
-			for (int i = 0; i < p.GetNumberOfTransitions(); i++)
-			{
-				ATNState target = p.Transition(i).target;
-				ATNConfig c = ATNConfig.Create(target, i + 1, initialContext);
-				Closure(input, c, configs, false);
-			}
-			return configs;
-		}
+        [NotNull]
+        protected internal virtual ATNConfigSet ComputeStartState(ICharStream input, ATNState
+             p)
+        {
+            PredictionContext initialContext = PredictionContext.EmptyFull;
+            ATNConfigSet configs = new OrderedATNConfigSet();
+            for (int i = 0; i < p.GetNumberOfTransitions(); i++)
+            {
+                ATNState target = p.Transition(i).target;
+                ATNConfig c = ATNConfig.Create(target, i + 1, initialContext);
+                Closure(input, c, configs, 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
-		/// <code>config</code>
-		/// , all other (potentially reachable) states for
-		/// this rule would have a lower priority.
-		/// </remarks>
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// if an accept state is reached, otherwise
-		/// <code>false</code>
-		/// .
-		/// </returns>
-		protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet
-			 configs, bool speculative)
-		{
-			if (config.GetState() is RuleStopState)
-			{
-				PredictionContext context = config.GetContext();
-				if (context.IsEmpty)
-				{
-					configs.AddItem(config);
-					return true;
-				}
-				else
-				{
-					if (context.HasEmpty)
-					{
-						configs.AddItem(config.Transform(config.GetState(), PredictionContext.EmptyFull));
-						return 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 = ATNConfig.Create(returnState, config.GetAlt(), newContext);
-					if (Closure(input, c, configs, speculative))
-					{
-						return true;
-					}
-				}
-				return false;
-			}
-			// optimization
-			if (!config.GetState().OnlyHasEpsilonTransitions())
-			{
-				configs.AddItem(config);
-			}
-			ATNState p = config.GetState();
-			for (int i_1 = 0; i_1 < p.GetNumberOfOptimizedTransitions(); i_1++)
-			{
-				Transition t = p.GetOptimizedTransition(i_1);
-				ATNConfig c = GetEpsilonTarget(input, config, t, configs, speculative);
-				if (c != null)
-				{
-					if (Closure(input, c, configs, speculative))
-					{
-						return true;
-					}
-				}
-			}
-			return false;
-		}
+        /// <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
+        /// <code>config</code>
+        /// , all other (potentially reachable) states for
+        /// this rule would have a lower priority.
+        /// </remarks>
+        /// <returns>
+        /// 
+        /// <code>true</code>
+        /// if an accept state is reached, otherwise
+        /// <code>false</code>
+        /// .
+        /// </returns>
+        protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet
+             configs, bool speculative)
+        {
+            if (config.GetState() is RuleStopState)
+            {
+                PredictionContext context = config.GetContext();
+                if (context.IsEmpty)
+                {
+                    configs.AddItem(config);
+                    return true;
+                }
+                else
+                {
+                    if (context.HasEmpty)
+                    {
+                        configs.AddItem(config.Transform(config.GetState(), PredictionContext.EmptyFull));
+                        return 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 = ATNConfig.Create(returnState, config.GetAlt(), newContext);
+                    if (Closure(input, c, configs, speculative))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            // optimization
+            if (!config.GetState().OnlyHasEpsilonTransitions())
+            {
+                configs.AddItem(config);
+            }
+            ATNState p = config.GetState();
+            for (int i_1 = 0; i_1 < p.GetNumberOfOptimizedTransitions(); i_1++)
+            {
+                Transition t = p.GetOptimizedTransition(i_1);
+                ATNConfig c = GetEpsilonTarget(input, config, t, configs, speculative);
+                if (c != null)
+                {
+                    if (Closure(input, c, configs, speculative))
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
 
-		// side-effect: can alter configs.hasSemanticContext
-		[Nullable]
-		public virtual ATNConfig GetEpsilonTarget(ICharStream input, ATNConfig config, Transition
-			 t, ATNConfigSet configs, bool speculative)
-		{
-			ATNConfig c;
-			switch (t.SerializationType)
-			{
-				case Transition.Rule:
-				{
-					RuleTransition ruleTransition = (RuleTransition)t;
-					if (optimize_tail_calls && ruleTransition.optimizedTailCall && !config.GetContext
-						().HasEmpty)
-					{
-						c = config.Transform(t.target);
-					}
-					else
-					{
-						PredictionContext newContext = config.GetContext().GetChild(ruleTransition.followState
-							.stateNumber);
-						c = config.Transform(t.target, newContext);
-					}
-					break;
-				}
+        // side-effect: can alter configs.hasSemanticContext
+        [Nullable]
+        public virtual ATNConfig GetEpsilonTarget(ICharStream input, ATNConfig config, Transition
+             t, ATNConfigSet configs, bool speculative)
+        {
+            ATNConfig c;
+            switch (t.SerializationType)
+            {
+                case Transition.Rule:
+                {
+                    RuleTransition ruleTransition = (RuleTransition)t;
+                    if (optimize_tail_calls && ruleTransition.optimizedTailCall && !config.GetContext
+                        ().HasEmpty)
+                    {
+                        c = config.Transform(t.target);
+                    }
+                    else
+                    {
+                        PredictionContext newContext = config.GetContext().GetChild(ruleTransition.followState
+                            .stateNumber);
+                        c = config.Transform(t.target, newContext);
+                    }
+                    break;
+                }
 
-				case Transition.Precedence:
-				{
-					throw new NotSupportedException("Precedence predicates are not supported in lexers."
-						);
-				}
+                case Transition.Precedence:
+                {
+                    throw new NotSupportedException("Precedence predicates are not supported in lexers."
+                        );
+                }
 
-				case Transition.Predicate:
-				{
-					PredicateTransition pt = (PredicateTransition)t;
-					configs.MarkExplicitSemanticContext();
-					if (EvaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative))
-					{
-						c = config.Transform(t.target);
-					}
-					else
-					{
-						c = null;
-					}
-					break;
-				}
+                case Transition.Predicate:
+                {
+                    PredicateTransition pt = (PredicateTransition)t;
+                    configs.MarkExplicitSemanticContext();
+                    if (EvaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative))
+                    {
+                        c = config.Transform(t.target);
+                    }
+                    else
+                    {
+                        c = null;
+                    }
+                    break;
+                }
 
-				case Transition.Action:
-				{
-					// ignore actions; just exec one per rule upon accept
-					c = config.Transform(t.target, ((ActionTransition)t).actionIndex);
-					break;
-				}
+                case Transition.Action:
+                {
+                    // ignore actions; just exec one per rule upon accept
+                    c = config.Transform(t.target, ((ActionTransition)t).actionIndex);
+                    break;
+                }
 
-				case Transition.Epsilon:
-				{
-					c = config.Transform(t.target);
-					break;
-				}
+                case Transition.Epsilon:
+                {
+                    c = config.Transform(t.target);
+                    break;
+                }
 
-				default:
-				{
-					c = null;
-					break;
-					break;
-				}
-			}
-			return c;
-		}
+                default:
+                {
+                    c = null;
+                    break;
+                    break;
+                }
+            }
+            return c;
+        }
 
-		/// <summary>Evaluate a predicate specified in the lexer.</summary>
-		/// <remarks>
-		/// Evaluate a predicate specified in the lexer.
-		/// <p/>
-		/// If
-		/// <code>speculative</code>
-		/// is
-		/// <code>true</code>
-		/// , this method was called before
-		/// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
-		/// 	</see>
-		/// for the matched character. This method should call
-		/// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
-		/// 	</see>
-		/// before evaluating the predicate to ensure position
-		/// sensitive values, including
-		/// <see cref="Antlr4.Runtime.Lexer.GetText()">Antlr4.Runtime.Lexer.GetText()</see>
-		/// ,
-		/// <see cref="Antlr4.Runtime.Lexer.Line()">Antlr4.Runtime.Lexer.Line()</see>
-		/// ,
-		/// and
-		/// <see cref="Antlr4.Runtime.Lexer.Column()">Antlr4.Runtime.Lexer.Column()</see>
-		/// , properly reflect the current
-		/// lexer state. This method should restore
-		/// <code>input</code>
-		/// 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)">Consume(Antlr4.Runtime.ICharStream)
-		/// 	</see>
-		/// .
-		/// </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">
-		/// 
-		/// <code>true</code>
-		/// if the current index in
-		/// <code>input</code>
-		/// is
-		/// one character before the predicate's location.
-		/// </param>
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// if the specified predicate evaluates to
-		/// <code>true</code>
-		/// .
-		/// </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);
-			}
-		}
+        /// <summary>Evaluate a predicate specified in the lexer.</summary>
+        /// <remarks>
+        /// Evaluate a predicate specified in the lexer.
+        /// <p/>
+        /// If
+        /// <code>speculative</code>
+        /// is
+        /// <code>true</code>
+        /// , this method was called before
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
+        ///     </see>
+        /// for the matched character. This method should call
+        /// <see cref="Consume(Antlr4.Runtime.ICharStream)">Consume(Antlr4.Runtime.ICharStream)
+        ///     </see>
+        /// before evaluating the predicate to ensure position
+        /// sensitive values, including
+        /// <see cref="Antlr4.Runtime.Lexer.GetText()">Antlr4.Runtime.Lexer.GetText()</see>
+        /// ,
+        /// <see cref="Antlr4.Runtime.Lexer.Line()">Antlr4.Runtime.Lexer.Line()</see>
+        /// ,
+        /// and
+        /// <see cref="Antlr4.Runtime.Lexer.Column()">Antlr4.Runtime.Lexer.Column()</see>
+        /// , properly reflect the current
+        /// lexer state. This method should restore
+        /// <code>input</code>
+        /// 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)">Consume(Antlr4.Runtime.ICharStream)
+        ///     </see>
+        /// .
+        /// </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">
+        /// 
+        /// <code>true</code>
+        /// if the current index in
+        /// <code>input</code>
+        /// is
+        /// one character before the predicate's location.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <code>true</code>
+        /// if the specified predicate evaluates to
+        /// <code>true</code>
+        /// .
+        /// </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;
-		}
+        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;
+        }
 
-		[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;
-		}
+        [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);
-			}
-		}
+        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>
-		[NotNull]
-		protected internal virtual DFAState AddDFAState(ATNConfigSet configs)
-		{
-			System.Diagnostics.Debug.Assert(!configs.HasSemanticContext());
-			DFAState proposed = new DFAState(configs, 0, MaxDfaEdge);
-			DFAState existing = atn.modeToDFA[mode].states.Get(proposed);
-			if (existing != null)
-			{
-				return existing;
-			}
-			configs.OptimizeConfigs(this);
-			DFAState newState = new DFAState(configs.Clone(true), 0, MaxDfaEdge);
-			ATNConfig firstConfigWithRuleStopState = null;
-			foreach (ATNConfig c in configs)
-			{
-				if (c.GetState() is RuleStopState)
-				{
-					firstConfigWithRuleStopState = c;
-					break;
-				}
-			}
-			if (firstConfigWithRuleStopState != null)
-			{
-				newState.isAcceptState = true;
-				newState.lexerRuleIndex = firstConfigWithRuleStopState.GetState().ruleIndex;
-				newState.lexerActionIndex = firstConfigWithRuleStopState.GetActionIndex();
-				newState.prediction = atn.ruleToTokenType[newState.lexerRuleIndex];
-			}
-			return atn.modeToDFA[mode].AddState(newState);
-		}
+        /// <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>
+        [NotNull]
+        protected internal virtual DFAState AddDFAState(ATNConfigSet configs)
+        {
+            System.Diagnostics.Debug.Assert(!configs.HasSemanticContext());
+            DFAState proposed = new DFAState(configs, 0, MaxDfaEdge);
+            DFAState existing = atn.modeToDFA[mode].states.Get(proposed);
+            if (existing != null)
+            {
+                return existing;
+            }
+            configs.OptimizeConfigs(this);
+            DFAState newState = new DFAState(configs.Clone(true), 0, MaxDfaEdge);
+            ATNConfig firstConfigWithRuleStopState = null;
+            foreach (ATNConfig c in configs)
+            {
+                if (c.GetState() is RuleStopState)
+                {
+                    firstConfigWithRuleStopState = c;
+                    break;
+                }
+            }
+            if (firstConfigWithRuleStopState != null)
+            {
+                newState.isAcceptState = true;
+                newState.lexerRuleIndex = firstConfigWithRuleStopState.GetState().ruleIndex;
+                newState.lexerActionIndex = firstConfigWithRuleStopState.GetActionIndex();
+                newState.prediction = atn.ruleToTokenType[newState.lexerRuleIndex];
+            }
+            return atn.modeToDFA[mode].AddState(newState);
+        }
 
-		[NotNull]
-		public DFA GetDFA(int mode)
-		{
-			return atn.modeToDFA[mode];
-		}
+        [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>
-		[NotNull]
-		public virtual string GetText(ICharStream input)
-		{
-			// index is first lookahead char, don't include.
-			return input.GetText(Interval.Of(startIndex, input.Index - 1));
-		}
+        /// <summary>Get the text matched so far for the current token.</summary>
+        /// <remarks>Get the text matched so far for the current token.</remarks>
+        [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 GetLine()
-		{
-			return line;
-		}
+        public virtual int GetLine()
+        {
+            return line;
+        }
 
-		public virtual void SetLine(int line)
-		{
-			this.line = line;
-		}
+        public virtual void SetLine(int line)
+        {
+            this.line = line;
+        }
 
-		public virtual int GetCharPositionInLine()
-		{
-			return charPositionInLine;
-		}
+        public virtual int GetCharPositionInLine()
+        {
+            return charPositionInLine;
+        }
 
-		public virtual void SetCharPositionInLine(int charPositionInLine)
-		{
-			this.charPositionInLine = charPositionInLine;
-		}
+        public virtual void SetCharPositionInLine(int charPositionInLine)
+        {
+            this.charPositionInLine = charPositionInLine;
+        }
 
-		public virtual void Consume(ICharStream input)
-		{
-			int curChar = input.La(1);
-			if (curChar == '\n')
-			{
-				line++;
-				charPositionInLine = 0;
-			}
-			else
-			{
-				charPositionInLine++;
-			}
-			input.Consume();
-		}
+        public virtual void Consume(ICharStream input)
+        {
+            int curChar = input.La(1);
+            if (curChar == '\n')
+            {
+                line++;
+                charPositionInLine = 0;
+            }
+            else
+            {
+                charPositionInLine++;
+            }
+            input.Consume();
+        }
 
-		[NotNull]
-		public virtual string GetTokenName(int t)
-		{
-			if (t == -1)
-			{
-				return "EOF";
-			}
-			//if ( atn.g!=null ) return atn.g.getTokenDisplayName(t);
-			return "'" + (char)t + "'";
-		}
-	}
+        [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/Antlr4.Runtime/Atn/LoopEndState.cs b/Antlr4.Runtime/Atn/LoopEndState.cs
index b701f7b91..fb3408bde 100644
--- a/Antlr4.Runtime/Atn/LoopEndState.cs
+++ b/Antlr4.Runtime/Atn/LoopEndState.cs
@@ -32,15 +32,15 @@ using 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;
+    /// <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 int GetStateType()
-		{
-			return LoopEnd;
-		}
-	}
+        public override int GetStateType()
+        {
+            return LoopEnd;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/NotSetTransition.cs b/Antlr4.Runtime/Atn/NotSetTransition.cs
index 41c0b814a..13971f27a 100644
--- a/Antlr4.Runtime/Atn/NotSetTransition.cs
+++ b/Antlr4.Runtime/Atn/NotSetTransition.cs
@@ -33,29 +33,29 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class NotSetTransition : SetTransition
-	{
-		public NotSetTransition(ATNState target, IntervalSet set) : base(target, set)
-		{
-		}
+    public sealed class NotSetTransition : SetTransition
+    {
+        public NotSetTransition(ATNState target, IntervalSet set) : base(target, set)
+        {
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return NotSet;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return NotSet;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !base.Matches(symbol
-				, minVocabSymbol, maxVocabSymbol);
-		}
+        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();
-		}
-	}
+        public override string ToString()
+        {
+            return '~' + base.ToString();
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs b/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
index 00ffbb737..06e9b95b1 100644
--- a/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
+++ b/Antlr4.Runtime/Atn/OrderedATNConfigSet.cs
@@ -32,38 +32,38 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public class OrderedATNConfigSet : ATNConfigSet
-	{
-		public OrderedATNConfigSet()
-		{
-		}
+    /// <author>Sam Harwell</author>
+    public class OrderedATNConfigSet : ATNConfigSet
+    {
+        public OrderedATNConfigSet()
+        {
+        }
 
-		protected internal OrderedATNConfigSet(ATNConfigSet set, bool @readonly) : base(set
-			, @readonly)
-		{
-		}
+        protected internal 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())
-			{
-				Sharpen.Collections.AddAll(copy, this);
-			}
-			return copy;
-		}
+        public override ATNConfigSet Clone(bool @readonly)
+        {
+            Antlr4.Runtime.Atn.OrderedATNConfigSet copy = new Antlr4.Runtime.Atn.OrderedATNConfigSet
+                (this, @readonly);
+            if (!@readonly && this.IsReadOnly())
+            {
+                Sharpen.Collections.AddAll(copy, this);
+            }
+            return copy;
+        }
 
-		protected internal override long GetKey(ATNConfig e)
-		{
-			return e.GetHashCode();
-		}
+        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);
-		}
-	}
+        protected internal override bool CanMerge(ATNConfig left, long leftKey, ATNConfig
+             right)
+        {
+            return left.Equals(right);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ParserATNPathFinder.cs b/Antlr4.Runtime/Atn/ParserATNPathFinder.cs
index 79200b6d7..431b705f8 100644
--- a/Antlr4.Runtime/Atn/ParserATNPathFinder.cs
+++ b/Antlr4.Runtime/Atn/ParserATNPathFinder.cs
@@ -32,146 +32,146 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public class ParserATNPathFinder
-	{
-		//	public ParserATNPathFinder(@Nullable Parser<Token> parser, @NotNull ATN atn) {
-		//		super(parser, atn);
-		//	}
-		//
-		//	/** Given an input sequence, as a subset of the input stream, trace the path through the
-		//	 *  ATN starting at s. The path returned includes s and the final target of the last input
-		//	 *  symbol. If there are multiple paths through the ATN to the final state, it uses the first
-		//	 *  method finds. This is used to figure out how input sequence is matched in more than one
-		//	 *  way between the alternatives of a decision. It's only that decision we are concerned with
-		//	 *  and so if there are ambiguous decisions further along, we will ignore them for the
-		//	 *  purposes of computing the path to the final state. To figure out multiple paths for
-		//	 *  decision, use this method  on the left edge of the alternatives of the decision in question.
-		//	 *
-		//	 *  TODO: I haven't figured out what to do with nongreedy decisions yet
-		//	 *  TODO: preds. unless i create rule specific ctxs, i can't eval preds. also must eval args!
-		//	 */
-		//	public TraceTree trace(@NotNull ATNState s, @Nullable RuleContext<Token> ctx,
-		//								TokenStream<? extends Token> input, int start, int stop)
-		//	{
-		//		System.out.println("REACHES "+s.stateNumber+" start state");
-		//		List<TraceTree> leaves = new ArrayList<TraceTree>();
-		//		@SuppressWarnings("unchecked") // safe
-		//		HashSet<ATNState>[] busy = (HashSet<ATNState>[])new HashSet<?>[stop-start+1];
-		//		for (int i = 0; i < busy.length; i++) {
-		//			busy[i] = new HashSet<ATNState>();
-		//		}
-		//		TraceTree path = _trace(s, ctx, ctx, input, start, start, stop, leaves, busy);
-		//		if ( path!=null ) path.leaves = leaves;
-		//		return path;
-		//	}
-		//
-		//	/** Returns true if we found path */
-		//	public TraceTree _trace(@NotNull ATNState s, RuleContext<Token> initialContext, RuleContext<Token> ctx,
-		//							TokenStream<? extends Token> input, int start, int i, int stop,
-		//							List<TraceTree> leaves, @NotNull Set<ATNState>[] busy)
-		//	{
-		//		TraceTree root = new TraceTree(s);
-		//		if ( i>stop ) {
-		//			leaves.add(root); // track final states
-		//			System.out.println("leaves=" + leaves);
-		//			return root;
-		//		}
-		//
-		//		if ( !busy[i-start].add(s) ) {
-		//			System.out.println("already visited "+s.stateNumber+" at input "+i+"="+input.get(i).getText());
-		//			return null;
-		//		}
-		//		busy[i-start].add(s);
-		//
-		//		System.out.println("TRACE "+s.stateNumber+" at input "+input.get(i).getText());
-		//
-		//		if ( s instanceof RuleStopState) {
-		//			// We hit rule end. If we have context info, use it
-		//			if ( ctx!=null && !ctx.isEmpty() ) {
-		//				System.out.println("stop state "+s.stateNumber+", ctx="+ctx);
-		//				ATNState invokingState = atn.states.get(ctx.invokingState);
-		//				RuleTransition rt = (RuleTransition)invokingState.transition(0);
-		//				ATNState retState = rt.followState;
-		//				return _trace(retState, initialContext, ctx.parent, input, start, i, stop, leaves, busy);
-		//			}
-		//			else {
-		//				// else if we have no context info, just chase follow links (if greedy)
-		//				System.out.println("FALLING off rule "+getRuleName(s.ruleIndex));
-		//			}
-		//		}
-		//
-		//		int n = s.getNumberOfTransitions();
-		//		boolean aGoodPath = false;
-		//		TraceTree found;
-		//		for (int j=0; j<n; j++) {
-		//			Transition t = s.transition(j);
-		//			if ( t.getClass() == RuleTransition.class ) {
-		//				RuleContext<Token> newContext = RuleContext.getChildContext(ctx, s.stateNumber);
-		//				found = _trace(t.target, initialContext, newContext, input, start, i, stop, leaves, busy);
-		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
-		//				continue;
-		//			}
-		//			if ( t instanceof PredicateTransition ) {
-		//				found = predTransition(initialContext, ctx, input, start, i, stop, leaves, busy, root, t);
-		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
-		//				continue;
-		//			}
-		//			if ( t.isEpsilon() ) {
-		//				found = _trace(t.target, initialContext, ctx, input, start, i, stop, leaves, busy);
-		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
-		//				continue;
-		//			}
-		//			if ( t.getClass() == WildcardTransition.class ) {
-		//				System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
-		//				found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
-		//				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
-		//				continue;
-		//			}
-		//			IntervalSet set = t.label();
-		//			if ( set!=null ) {
-		//				if ( t instanceof NotSetTransition ) {
-		//					if ( !set.contains(input.get(i).getType()) ) {
-		//						System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
-		//						found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
-		//						if ( found!=null ) {aGoodPath=true; root.addChild(found);}
-		//					}
-		//				}
-		//				else {
-		//					if ( set.contains(input.get(i).getType()) ) {
-		//						System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
-		//						found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
-		//						if ( found!=null ) {aGoodPath=true; root.addChild(found);}
-		//					}
-		//				}
-		//			}
-		//		}
-		//		if ( aGoodPath ) return root; // found at least one transition leading to success
-		//		return null;
-		//	}
-		//
-		//	public TraceTree predTransition(RuleContext<Token> initialContext, RuleContext<Token> ctx, TokenStream<? extends Token> input, int start,
-		//									int i, int stop, List<TraceTree> leaves, Set<ATNState>[] busy,
-		//									TraceTree root, Transition t)
-		//	{
-		//		SemanticContext.Predicate pred = ((PredicateTransition) t).getPredicate();
-		//		boolean pass;
-		//		if ( pred.isCtxDependent ) {
-		//			if ( ctx instanceof ParserRuleContext && ctx==initialContext ) {
-		//				System.out.println("eval pred "+pred+"="+pred.eval(parser, ctx));
-		//				pass = pred.eval(parser, ctx);
-		//			}
-		//			else {
-		//				pass = true; // see thru ctx dependent when out of context
-		//			}
-		//		}
-		//		else {
-		//			System.out.println("eval pred "+pred+"="+pred.eval(parser, initialContext));
-		//			pass = pred.eval(parser, ctx);
-		//		}
-		//		if ( pass ) {
-		//			return _trace(t.target, initialContext, ctx, input, start, i, stop, leaves, busy);
-		//		}
-		//		return null;
-		//	}
-	}
+    public class ParserATNPathFinder
+    {
+        //	public ParserATNPathFinder(@Nullable Parser<Token> parser, @NotNull ATN atn) {
+        //		super(parser, atn);
+        //	}
+        //
+        //	/** Given an input sequence, as a subset of the input stream, trace the path through the
+        //	 *  ATN starting at s. The path returned includes s and the final target of the last input
+        //	 *  symbol. If there are multiple paths through the ATN to the final state, it uses the first
+        //	 *  method finds. This is used to figure out how input sequence is matched in more than one
+        //	 *  way between the alternatives of a decision. It's only that decision we are concerned with
+        //	 *  and so if there are ambiguous decisions further along, we will ignore them for the
+        //	 *  purposes of computing the path to the final state. To figure out multiple paths for
+        //	 *  decision, use this method  on the left edge of the alternatives of the decision in question.
+        //	 *
+        //	 *  TODO: I haven't figured out what to do with nongreedy decisions yet
+        //	 *  TODO: preds. unless i create rule specific ctxs, i can't eval preds. also must eval args!
+        //	 */
+        //	public TraceTree trace(@NotNull ATNState s, @Nullable RuleContext<Token> ctx,
+        //								TokenStream<? extends Token> input, int start, int stop)
+        //	{
+        //		System.out.println("REACHES "+s.stateNumber+" start state");
+        //		List<TraceTree> leaves = new ArrayList<TraceTree>();
+        //		@SuppressWarnings("unchecked") // safe
+        //		HashSet<ATNState>[] busy = (HashSet<ATNState>[])new HashSet<?>[stop-start+1];
+        //		for (int i = 0; i < busy.length; i++) {
+        //			busy[i] = new HashSet<ATNState>();
+        //		}
+        //		TraceTree path = _trace(s, ctx, ctx, input, start, start, stop, leaves, busy);
+        //		if ( path!=null ) path.leaves = leaves;
+        //		return path;
+        //	}
+        //
+        //	/** Returns true if we found path */
+        //	public TraceTree _trace(@NotNull ATNState s, RuleContext<Token> initialContext, RuleContext<Token> ctx,
+        //							TokenStream<? extends Token> input, int start, int i, int stop,
+        //							List<TraceTree> leaves, @NotNull Set<ATNState>[] busy)
+        //	{
+        //		TraceTree root = new TraceTree(s);
+        //		if ( i>stop ) {
+        //			leaves.add(root); // track final states
+        //			System.out.println("leaves=" + leaves);
+        //			return root;
+        //		}
+        //
+        //		if ( !busy[i-start].add(s) ) {
+        //			System.out.println("already visited "+s.stateNumber+" at input "+i+"="+input.get(i).getText());
+        //			return null;
+        //		}
+        //		busy[i-start].add(s);
+        //
+        //		System.out.println("TRACE "+s.stateNumber+" at input "+input.get(i).getText());
+        //
+        //		if ( s instanceof RuleStopState) {
+        //			// We hit rule end. If we have context info, use it
+        //			if ( ctx!=null && !ctx.isEmpty() ) {
+        //				System.out.println("stop state "+s.stateNumber+", ctx="+ctx);
+        //				ATNState invokingState = atn.states.get(ctx.invokingState);
+        //				RuleTransition rt = (RuleTransition)invokingState.transition(0);
+        //				ATNState retState = rt.followState;
+        //				return _trace(retState, initialContext, ctx.parent, input, start, i, stop, leaves, busy);
+        //			}
+        //			else {
+        //				// else if we have no context info, just chase follow links (if greedy)
+        //				System.out.println("FALLING off rule "+getRuleName(s.ruleIndex));
+        //			}
+        //		}
+        //
+        //		int n = s.getNumberOfTransitions();
+        //		boolean aGoodPath = false;
+        //		TraceTree found;
+        //		for (int j=0; j<n; j++) {
+        //			Transition t = s.transition(j);
+        //			if ( t.getClass() == RuleTransition.class ) {
+        //				RuleContext<Token> newContext = RuleContext.getChildContext(ctx, s.stateNumber);
+        //				found = _trace(t.target, initialContext, newContext, input, start, i, stop, leaves, busy);
+        //				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+        //				continue;
+        //			}
+        //			if ( t instanceof PredicateTransition ) {
+        //				found = predTransition(initialContext, ctx, input, start, i, stop, leaves, busy, root, t);
+        //				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+        //				continue;
+        //			}
+        //			if ( t.isEpsilon() ) {
+        //				found = _trace(t.target, initialContext, ctx, input, start, i, stop, leaves, busy);
+        //				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+        //				continue;
+        //			}
+        //			if ( t.getClass() == WildcardTransition.class ) {
+        //				System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
+        //				found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
+        //				if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+        //				continue;
+        //			}
+        //			IntervalSet set = t.label();
+        //			if ( set!=null ) {
+        //				if ( t instanceof NotSetTransition ) {
+        //					if ( !set.contains(input.get(i).getType()) ) {
+        //						System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
+        //						found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
+        //						if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+        //					}
+        //				}
+        //				else {
+        //					if ( set.contains(input.get(i).getType()) ) {
+        //						System.out.println("REACHES " + t.target.stateNumber + " matching input " + input.get(i).getText());
+        //						found = _trace(t.target, initialContext, ctx, input, start, i+1, stop, leaves, busy);
+        //						if ( found!=null ) {aGoodPath=true; root.addChild(found);}
+        //					}
+        //				}
+        //			}
+        //		}
+        //		if ( aGoodPath ) return root; // found at least one transition leading to success
+        //		return null;
+        //	}
+        //
+        //	public TraceTree predTransition(RuleContext<Token> initialContext, RuleContext<Token> ctx, TokenStream<? extends Token> input, int start,
+        //									int i, int stop, List<TraceTree> leaves, Set<ATNState>[] busy,
+        //									TraceTree root, Transition t)
+        //	{
+        //		SemanticContext.Predicate pred = ((PredicateTransition) t).getPredicate();
+        //		boolean pass;
+        //		if ( pred.isCtxDependent ) {
+        //			if ( ctx instanceof ParserRuleContext && ctx==initialContext ) {
+        //				System.out.println("eval pred "+pred+"="+pred.eval(parser, ctx));
+        //				pass = pred.eval(parser, ctx);
+        //			}
+        //			else {
+        //				pass = true; // see thru ctx dependent when out of context
+        //			}
+        //		}
+        //		else {
+        //			System.out.println("eval pred "+pred+"="+pred.eval(parser, initialContext));
+        //			pass = pred.eval(parser, ctx);
+        //		}
+        //		if ( pass ) {
+        //			return _trace(t.target, initialContext, ctx, input, start, i, stop, leaves, busy);
+        //		}
+        //		return null;
+        //	}
+    }
 }
diff --git a/Antlr4.Runtime/Atn/ParserATNSimulator.cs b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
index 13c033df0..dc5314150 100644
--- a/Antlr4.Runtime/Atn/ParserATNSimulator.cs
+++ b/Antlr4.Runtime/Atn/ParserATNSimulator.cs
@@ -36,2147 +36,2148 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>The embodiment of the adaptive LL(*) parsing strategy.</summary>
-	/// <remarks>
-	/// The embodiment of the adaptive LL(*) 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
-	/// 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 entry rule.  For
-	/// example, if prediction occurs without invoking another rule's
-	/// ATN, there are no context stacks in the configurations. When this
-	/// 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(*)).
-	/// So, we simply retry the ATN simulation again, this time
-	/// using full outer context and filling a dummy DFA (to avoid
-	/// polluting the context insensitive DFA). Configuration context
-	/// stacks will be the full invocation stack 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.) We create a special DFA accept state
-	/// that maps rule context to a predicted alternative. That is the
-	/// only modification needed to handle full LL(*) prediction. In
-	/// general, full context prediction will use more lookahead than
-	/// necessary, but it pays to share the same DFA. For a schedule
-	/// proof that full context prediction uses that most the same amount
-	/// of lookahead as a context insensitive prediction, see the comment
-	/// on method retryWithContext().
-	/// So, the strategy is complex because we bounce back and forth from
-	/// the ATN to the DFA, simultaneously performing predictions and
-	/// extending the DFA according to previously unseen input
-	/// sequences. The retry with full context is a recursive call to the
-	/// same function naturally because it does the same thing, just with
-	/// a different initial context. The problem is, that we need to pass
-	/// in a "full context mode" parameter so that it knows to report
-	/// conflicts differently. It also knows not to do a retry, to avoid
-	/// infinite recursion, if it is already using full context.
-	/// Retry a simulation using full outer context.
-	/// One of the key assumptions here is that using full context
-	/// can use at most the same amount of input as a simulation
-	/// that is not useful context (i.e., it uses all possible contexts
-	/// that could invoke our entry rule. I believe that this is true
-	/// and the proof might go like this.
-	/// THEOREM:  The amount of input consumed during a full context
-	/// simulation is at most the amount of input consumed during a
-	/// non full context simulation.
-	/// PROOF: Let D be the DFA state at which non-context simulation
-	/// terminated. That means that D does not have a configuration for
-	/// which we can legally pursue more input. (It is legal to work only
-	/// on configurations for which there is no conflict with another
-	/// configuration.) Now we restrict ourselves to following ATN edges
-	/// associated with a single context. Choose any DFA state D' along
-	/// the path (same input) to D. That state has either the same number
-	/// of configurations or fewer. (If the number of configurations is
-	/// the same, then we have degenerated to the non-context case.) Now
-	/// imagine that we restrict to following edges associated with
-	/// another single context and that we reach DFA state D'' for the
-	/// same amount of input as D'. The non-context simulation merges D'
-	/// and D''. The union of the configuration sets either has the same
-	/// number of configurations as both D' and D'' or it has more. If it
-	/// has the same number, we are no worse off and the merge does not
-	/// force us to look for more input than we would otherwise have to
-	/// do. If the union has more configurations, it can introduce
-	/// conflicts but not new alternatives--we cannot conjure up alternatives
-	/// by computing closure on the DFA state.  Here are the cases for
-	/// D' union D'':
-	/// 1. No increase in configurations, D' = D''
-	/// 2. Add configuration that introduces a new alternative number.
-	/// This cannot happen because no new alternatives are introduced
-	/// while computing closure, even during start state computation.
-	/// 3. D'' adds a configuration that does not conflict with any
-	/// configuration in D'.  Simulating without context would then have
-	/// forced us to use more lookahead than D' (full context) alone.
-	/// 3. D'' adds a configuration that introduces a conflict with a
-	/// configuration in D'. There are 2 cases:
-	/// a. The conflict does not cause termination (D' union D''
-	/// is added to the work list). Again no context simulation requires
-	/// more input.
-	/// b. The conflict does cause termination, but this cannot happen.
-	/// By definition, we know that with ALL contexts merged we
-	/// don't terminate until D and D' uses less input than D. Therefore
-	/// no context simulation requires more input than full context
-	/// simulation.
-	/// We have covered all the cases and there is never a situation where
-	/// a single, full context simulation requires more input than a
-	/// no context simulation.
-	/// I spent a bunch of time thinking about this problem after finding
-	/// a case where context-sensitive ATN simulation looks beyond what they
-	/// no context simulation uses. the no context simulation for if then else
-	/// stops at the else whereas full context scans through to the end of the
-	/// statement to decide that the "else statement" clause is ambiguous. And
-	/// sometimes it is not ambiguous! Ok, I made an untrue assumption in my
-	/// proof which I won't bother going to. the important thing is what I'm
-	/// going to do about it. I thought I had a simple answer, but nope. It
-	/// turns out that the if then else case is perfect example of something
-	/// that has the following characteristics:
-	/// no context conflicts at k=1
-	/// full context at k=(1 + length of statement) can be both ambiguous and not
-	/// ambiguous depending on the input, though I think from different contexts.
-	/// But, the good news is that the k=1 case is a special case in that
-	/// SLL(1) and LL(1) have exactly the same power so we can conclude that
-	/// conflicts at k=1 are true ambiguities and we do not need to pursue
-	/// context-sensitive parsing. That covers a huge number of cases
-	/// including the if then else clause and the predicated precedence
-	/// parsing mechanism. whew! because that could be extremely expensive if
-	/// we had to do context.
-	/// Further, there is no point in doing full context if none of the
-	/// configurations dip into the outer context. This nicely handles cases
-	/// such 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.
-	/// So, we now cover what I hope is the vast majority of the cases (in
-	/// particular the very important precedence parsing case). Anything that
-	/// needs k&gt;1 and dips into the outer context requires a full context
-	/// retry. In this case, I'm going to start out with a brain-dead solution
-	/// which is to mark the DFA state as context-sensitive when I get a
-	/// conflict. Any further DFA simulation that reaches that state will
-	/// launch an ATN simulation to get the prediction, without updating the
-	/// DFA or storing any context information. Later, I can make this more
-	/// efficient, but at least in this case I can guarantee that it will
-	/// always do the right thing. We are not making any assumptions about
-	/// lookahead depth.
-	/// Ok, writing this up so I can put in a comment.
-	/// Upon conflict in the no context simulation:
-	/// if k=1, report ambiguity and resolve to the minimum conflicting alternative
-	/// if k=1 and predicates, no report and include the predicate to
-	/// predicted alternative map in the DFA state
-	/// if k=* and we did not dip into the outer context, report ambiguity
-	/// and resolve to minimum conflicting alternative
-	/// if k&gt;1 and we dip into outer context, retry with full context
-	/// if conflict, report ambiguity and resolve to minimum conflicting
-	/// alternative, mark DFA as context-sensitive
-	/// If no conflict, report ctx sensitivity and mark DFA as context-sensitive
-	/// Technically, if full context k is less than no context k, we can
-	/// reuse the conflicting DFA state so we don't have to create special
-	/// DFA paths branching from context, but we can leave that for
-	/// optimization later if necessary.
-	/// if non-greedy, no report and resolve to the exit alternative
-	/// 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>
-	public class ParserATNSimulator : ATNSimulator
-	{
-		public const bool debug = false;
-
-		public const bool dfa_debug = false;
-
-		public const bool retry_debug = false;
-
-		private PredictionMode predictionMode = PredictionMode.Ll;
-
-		public bool force_global_context = false;
-
-		public bool always_try_local_context = true;
-
-		public bool optimize_unique_closure = true;
-
-		public bool optimize_ll1 = true;
-
-		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;
-
-		public static bool optimize_closure_busy = true;
-
-		[Nullable]
-		protected internal readonly Parser parser;
-
-		/// <summary>
-		/// When
-		/// <code>true</code>
-		/// , ambiguous alternatives are reported when they are
-		/// encountered within
-		/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)
-		/// 	">ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)
-		/// 	</see>
-		/// . When
-		/// <code>false</code>
-		/// , these messages
-		/// are suppressed. The default is
-		/// <code>false</code>
-		/// .
-		/// <p>
-		/// When messages about ambiguous alternatives are not required, setting this
-		/// to
-		/// <code>false</code>
-		/// 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;
-
-		/// <summary>Testing only!</summary>
-		public ParserATNSimulator(ATN atn) : this(null, atn)
-		{
-		}
-
-		public ParserATNSimulator(Parser parser, ATN atn) : base(atn)
-		{
-			this.parser = parser;
-		}
-
-		[NotNull]
-		public PredictionMode GetPredictionMode()
-		{
-			return predictionMode;
-		}
-
-		public void SetPredictionMode(PredictionMode predictionMode)
-		{
-			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.IsEmpty())
-			{
-				int ll_1 = input.La(1);
-				if (ll_1 >= 0 && ll_1 <= short.MaxValue)
-				{
-					int key = (decision << 16) + ll_1;
-					int alt = atn.LL1Table.Get(key);
-					if (alt != null)
-					{
-						return alt;
-					}
-				}
-			}
-			if (force_global_context)
-			{
-				useContext = true;
-			}
-			else
-			{
-				if (!always_try_local_context)
-				{
-					useContext |= dfa != null && dfa.IsContextSensitive();
-				}
-			}
-			userWantsCtxSensitive = useContext || (predictionMode != PredictionMode.Sll && outerContext
-				 != null && !atn.decisionToState[decision].sll);
-			if (outerContext == null)
-			{
-				outerContext = ParserRuleContext.EmptyContext();
-			}
-			SimulatorState state = null;
-			if (!dfa.IsEmpty())
-			{
-				state = GetStartState(dfa, input, outerContext, useContext);
-			}
-			if (state == null)
-			{
-				return PredictATN(dfa, input, outerContext, useContext);
-			}
-			else
-			{
-				//dump(dfa);
-				// start with the DFA
-				int m = input.Mark();
-				int index = input.Index;
-				try
-				{
-					int alt = ExecDFA(dfa, input, index, state);
-					return alt;
-				}
-				finally
-				{
-					input.Seek(index);
-					input.Release(m);
-				}
-			}
-		}
-
-		public virtual SimulatorState GetStartState(DFA dfa, ITokenStream input, ParserRuleContext
-			 outerContext, bool useContext)
-		{
-			if (!useContext)
-			{
-				if (dfa.s0.Get() == null)
-				{
-					return null;
-				}
-				return new SimulatorState(outerContext, dfa.s0.Get(), false, outerContext);
-			}
-			ParserRuleContext remainingContext = outerContext;
-			System.Diagnostics.Debug.Assert(outerContext != null);
-			DFAState 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);
-		}
-
-		public virtual int PredictATN(DFA dfa, ITokenStream input, ParserRuleContext outerContext
-			, bool useContext)
-		{
-			if (outerContext == null)
-			{
-				outerContext = ParserRuleContext.EmptyContext();
-			}
-			int alt = 0;
-			int m = input.Mark();
-			int index = input.Index;
-			try
-			{
-				SimulatorState state = ComputeStartState(dfa, outerContext, useContext);
-				if (state.s0.isAcceptState)
-				{
-					return ExecDFA(dfa, input, index, state);
-				}
-				else
-				{
-					alt = ExecATN(dfa, input, index, state);
-				}
-			}
-			catch (NoViableAltException nvae)
-			{
-				throw;
-			}
-			finally
-			{
-				input.Seek(index);
-				input.Release(m);
-			}
-			return alt;
-		}
-
-		public virtual int ExecDFA(DFA dfa, ITokenStream input, int startIndex, SimulatorState
-			 state)
-		{
-			ParserRuleContext outerContext = state.outerContext;
-			DFAState acceptState = null;
-			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);
-						}
-						remainingOuterContext = ((ParserRuleContext)remainingOuterContext.Parent);
-						s = next;
-					}
-				}
-				if (s.isAcceptState)
-				{
-					if (s.predicates != null)
-					{
-					}
-					acceptState = s;
-					// 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(!s.isAcceptState);
-				// if no edge, pop over to ATN interpreter, update DFA and return
-				DFAState target = s.GetTarget(t);
-				if (target == null)
-				{
-					if (dfa_debug && t >= 0)
-					{
-						System.Console.Out.WriteLine("no edge for " + parser.GetTokenNames()[t]);
-					}
-					int alt;
-					SimulatorState initialState = new SimulatorState(outerContext, s, state.useContext
-						, remainingOuterContext);
-					alt = ExecATN(dfa, input, startIndex, initialState);
-					// this adds edge even if next state is accept for
-					// same alt; e.g., s0-A->:s1=>2-B->:s2=>2
-					// TODO: This next stuff kills edge, but extra states remain. :(
-					if (s.isAcceptState && alt != -1)
-					{
-						DFAState d = s.GetTarget(input.La(1));
-						if (d.isAcceptState && d.prediction == s.prediction)
-						{
-							// we can carve it out.
-							s.SetTarget(input.La(1), Error);
-						}
-					}
-					// IGNORE really not error
-					//dump(dfa);
-					// action already executed
-					return alt;
-				}
-				else
-				{
-					// we've updated DFA, exec'd action, and have our deepest answer
-					if (target == Error)
-					{
-						throw NoViableAlt(input, outerContext, s.configs, startIndex);
-					}
-				}
-				s = target;
-				if (!s.isAcceptState && t != IIntStream.Eof)
-				{
-					input.Consume();
-					t = input.La(1);
-				}
-			}
-			//		if ( acceptState==null ) {
-			//			if ( debug ) System.out.println("!!! no viable alt in dfa");
-			//			return -1;
-			//		}
-			if (acceptState.configs.GetConflictingAlts() != null)
-			{
-				if (dfa.atnStartState is DecisionState)
-				{
-					if (!userWantsCtxSensitive || !acceptState.configs.GetDipsIntoOuterContext() || (
-						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
-						if (acceptState.predicates != null)
-						{
-							int conflictIndex = input.Index;
-							if (conflictIndex != startIndex)
-							{
-								input.Seek(startIndex);
-							}
-							BitSet predictions = EvalSemanticContext(s.predicates, outerContext, true);
-							if (predictions.Cardinality() == 1)
-							{
-								return predictions.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 fullContextState = ComputeStartState(dfa, outerContext, true);
-							ReportAttemptingFullContext(dfa, fullContextState, 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
-			if (s.predicates != null)
-			{
-				int stopIndex = input.Index;
-				if (startIndex != stopIndex)
-				{
-					input.Seek(startIndex);
-				}
-				BitSet alts = EvalSemanticContext(s.predicates, outerContext, reportAmbiguities &&
-					 predictionMode == 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, alts, s.configs);
-						return alts.NextSetBit(0);
-						break;
-					}
-				}
-			}
-			return acceptState.prediction;
-		}
-
-		/// <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>
-		public virtual int ExecATN(DFA dfa, ITokenStream input, int startIndex, SimulatorState
-			 initialState)
-		{
-			ParserRuleContext outerContext = initialState.outerContext;
-			bool useContext = initialState.useContext;
-			int t = input.La(1);
-			DecisionState decState = atn.GetDecisionState(dfa.decision);
-			SimulatorState previous = initialState;
-			PredictionContextCache contextCache = new PredictionContextCache();
-			while (true)
-			{
-				// while more work
-				SimulatorState nextState = ComputeReachSet(dfa, previous, t, contextCache);
-				if (nextState == null)
-				{
-					return HandleNoViableAlt(input, startIndex, previous);
-				}
-				DFAState D = nextState.s0;
-				ATNConfigSet reach = D.configs;
-				// predicted alt => accept state
-				System.Diagnostics.Debug.Assert(D.isAcceptState || GetUniqueAlt(reach) == ATN.InvalidAltNumber
-					);
-				// conflicted => accept state
-				System.Diagnostics.Debug.Assert(D.isAcceptState || D.configs.GetConflictingAlts()
-					 == null);
-				if (D.isAcceptState)
-				{
-					int predictedAlt = reach.GetConflictingAlts() == null ? GetUniqueAlt(reach) : ATN
-						.InvalidAltNumber;
-					if (predictedAlt != ATN.InvalidAltNumber)
-					{
-						if (optimize_ll1 && input.Index == startIndex && nextState.outerContext == nextState
-							.remainingOuterContext && dfa.decision >= 0 && !D.configs.HasSemanticContext())
-						{
-							if (t >= 0 && t <= short.MaxValue)
-							{
-								int key = (dfa.decision << 16) + t;
-								atn.LL1Table.Put(key, predictedAlt);
-							}
-						}
-						if (useContext && always_try_local_context)
-						{
-							ReportContextSensitivity(dfa, nextState, startIndex, input.Index);
-						}
-					}
-					else
-					{
-						if (D.configs.GetConflictingAlts() != null)
-						{
-							predictedAlt = D.prediction;
-							//						int k = input.index() - startIndex + 1; // how much input we used
-							//						System.out.println("used k="+k);
-							if (!userWantsCtxSensitive || !D.configs.GetDipsIntoOuterContext() || (treat_sllk1_conflict_as_ambiguity
-								 && input.Index == startIndex))
-							{
-								if (reportAmbiguities && !D.configs.HasSemanticContext())
-								{
-									ReportAmbiguity(dfa, D, startIndex, input.Index, D.configs.GetConflictingAlts(), 
-										D.configs);
-								}
-							}
-							else
-							{
-								System.Diagnostics.Debug.Assert(!useContext);
-								System.Diagnostics.Debug.Assert(D.isAcceptState);
-								if (D.configs.HasSemanticContext())
-								{
-									int nalts = decState.GetNumberOfTransitions();
-									DFAState.PredPrediction[] predPredictions = D.predicates;
-									if (predPredictions != null)
-									{
-										int conflictIndex = input.Index;
-										if (conflictIndex != startIndex)
-										{
-											input.Seek(startIndex);
-										}
-										// always use complete evaluation here since we'll want to retry with full context if still ambiguous
-										BitSet alts = EvalSemanticContext(predPredictions, outerContext, true);
-										if (alts.Cardinality() == 1)
-										{
-											return alts.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);
-										}
-									}
-								}
-								SimulatorState fullContextState = ComputeStartState(dfa, outerContext, true);
-								if (reportAmbiguities)
-								{
-									ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index);
-								}
-								input.Seek(startIndex);
-								return ExecATN(dfa, input, startIndex, fullContextState);
-							}
-						}
-					}
-					if (D.predicates != null)
-					{
-						int stopIndex = input.Index;
-						if (startIndex != stopIndex)
-						{
-							input.Seek(startIndex);
-						}
-						BitSet alts = EvalSemanticContext(D.predicates, outerContext, reportAmbiguities &&
-							 predictionMode == PredictionMode.LlExactAmbigDetection);
-						D.prediction = ATN.InvalidAltNumber;
-						switch (alts.Cardinality())
-						{
-							case 0:
-							{
-								throw NoViableAlt(input, outerContext, D.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, D, startIndex, stopIndex, alts, D.configs);
-								return alts.NextSetBit(0);
-								break;
-							}
-						}
-					}
-					return predictedAlt;
-				}
-				previous = nextState;
-				if (t != IIntStream.Eof)
-				{
-					input.Consume();
-					t = input.La(1);
-				}
-			}
-		}
-
-		protected internal virtual int HandleNoViableAlt(ITokenStream input, int startIndex
-			, SimulatorState previous)
-		{
-			if (previous.s0 != null)
-			{
-				BitSet alts = new BitSet();
-				foreach (ATNConfig config in previous.s0.configs)
-				{
-					if (config.GetReachesIntoOuterContext() || config.GetState() is RuleStopState)
-					{
-						alts.Set(config.GetAlt());
-					}
-				}
-				if (!alts.IsEmpty())
-				{
-					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;
-					}
-					remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
-					s = next;
-				}
-			}
-			System.Diagnostics.Debug.Assert(!s.isAcceptState);
-			if (s.isAcceptState)
-			{
-				return new SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext
-					);
-			}
-			DFAState s0 = s;
-			DFAState existingTarget = s0 != null ? s0.GetTarget(t) : null;
-			if (existingTarget != null)
-			{
-				return new SimulatorState(previous.outerContext, existingTarget, useContext, remainingGlobalContext
-					);
-			}
-			IList<ATNConfig> closureConfigs = new List<ATNConfig>(s0.configs);
-			IntegerList contextElements = null;
-			ATNConfigSet reach = new ATNConfigSet();
-			bool stepIntoGlobal;
-			do
-			{
-				bool hasMoreContext = !useContext || remainingGlobalContext != null;
-				if (!hasMoreContext)
-				{
-					reach.SetOutermostConfigSet(true);
-				}
-				ATNConfigSet reachIntermediate = new ATNConfigSet();
-				IList<ATNConfig> skippedStopStates = null;
-				foreach (ATNConfig c in closureConfigs)
-				{
-					if (c.GetState() is RuleStopState)
-					{
-						System.Diagnostics.Debug.Assert(c.GetContext().IsEmpty);
-						if (useContext && !c.GetReachesIntoOuterContext() || t == IIntStream.Eof)
-						{
-							if (skippedStopStates == null)
-							{
-								skippedStopStates = new List<ATNConfig>();
-							}
-							skippedStopStates.AddItem(c);
-						}
-						continue;
-					}
-					int n = c.GetState().GetNumberOfOptimizedTransitions();
-					for (int ti = 0; ti < n; ti++)
-					{
-						// for each optimized transition
-						Transition trans = c.GetState().GetOptimizedTransition(ti);
-						ATNState target = GetReachableTarget(c, trans, t);
-						if (target != null)
-						{
-							reachIntermediate.Add(c.Transform(target), contextCache);
-						}
-					}
-				}
-				if (optimize_unique_closure && skippedStopStates == null && reachIntermediate.GetUniqueAlt
-					() != ATN.InvalidAltNumber)
-				{
-					reachIntermediate.SetOutermostConfigSet(reach.IsOutermostConfigSet());
-					reach = reachIntermediate;
-					break;
-				}
-				bool collectPredicates = false;
-				Closure(reachIntermediate, reach, collectPredicates, hasMoreContext, contextCache
-					);
-				stepIntoGlobal = reach.GetDipsIntoOuterContext();
-				if (t == IIntStream.Eof)
-				{
-					reach = RemoveAllConfigsNotInRuleStopState(reach, contextCache);
-				}
-				if (skippedStopStates != null && (!useContext || !PredictionMode.HasConfigInRuleStopState
-					(reach)))
-				{
-					System.Diagnostics.Debug.Assert(!skippedStopStates.IsEmpty());
-					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 IntegerList();
-					}
-					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.Set(i, closureConfigs[i].AppendContext(nextContextElement, contextCache
-								));
-						}
-					}
-				}
-			}
-			while (useContext && stepIntoGlobal);
-			if (reach.IsEmpty())
-			{
-				return null;
-			}
-			DFAState dfaState = null;
-			if (s0 != null)
-			{
-				dfaState = AddDFAEdge(dfa, s0, t, contextElements, reach, contextCache);
-			}
-			System.Diagnostics.Debug.Assert(!useContext || !dfaState.configs.GetDipsIntoOuterContext
-				());
-			return new SimulatorState(previous.outerContext, dfaState, useContext, remainingGlobalContext
-				);
-		}
-
-		/// <summary>
-		/// Return a configuration set containing only the configurations from
-		/// <code>configs</code>
-		/// which are in a
-		/// <see cref="RuleStopState">RuleStopState</see>
-		/// . If all
-		/// configurations in
-		/// <code>configs</code>
-		/// are already in a rule stop state, this
-		/// method simply returns
-		/// <code>configs</code>
-		/// .
-		/// </summary>
-		/// <param name="configs">the configuration set to update</param>
-		/// <param name="contextCache">
-		/// the
-		/// <see cref="PredictionContext">PredictionContext</see>
-		/// cache
-		/// </param>
-		/// <returns>
-		/// 
-		/// <code>configs</code>
-		/// if all configurations in
-		/// <code>configs</code>
-		/// are in a
-		/// rule stop state, otherwise return a new configuration set containing only
-		/// the configurations from
-		/// <code>configs</code>
-		/// which are in a rule stop state
-		/// </returns>
-		[NotNull]
-		protected internal virtual ATNConfigSet RemoveAllConfigsNotInRuleStopState(ATNConfigSet
-			 configs, PredictionContextCache contextCache)
-		{
-			if (PredictionMode.AllConfigsInRuleStopStates(configs))
-			{
-				return configs;
-			}
-			ATNConfigSet result = new ATNConfigSet();
-			foreach (ATNConfig config in configs)
-			{
-				if (!(config.GetState() is RuleStopState))
-				{
-					continue;
-				}
-				result.Add(config, contextCache);
-			}
-			return result;
-		}
-
-		[NotNull]
-		public virtual SimulatorState ComputeStartState(DFA dfa, ParserRuleContext globalContext
-			, bool useContext)
-		{
-			DFAState s0 = useContext ? dfa.s0full.Get() : dfa.s0.Get();
-			if (s0 != null)
-			{
-				if (!useContext)
-				{
-					return new SimulatorState(globalContext, s0, useContext, globalContext);
-				}
-				s0.SetContextSensitive(atn);
-			}
-			int decision = dfa.decision;
-			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)
-			{
-				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.GetNumberOfTransitions();
-				for (int ti = 0; ti < n; ti++)
-				{
-					// for each transition
-					ATNState target = p.Transition(ti).target;
-					reachIntermediate.AddItem(ATNConfig.Create(target, ti + 1, initialContext));
-				}
-				bool hasMoreContext = remainingGlobalContext != null;
-				if (!hasMoreContext)
-				{
-					configs.SetOutermostConfigSet(true);
-				}
-				bool collectPredicates = true;
-				Closure(reachIntermediate, configs, collectPredicates, hasMoreContext, contextCache
-					);
-				bool stepIntoGlobal = configs.GetDipsIntoOuterContext();
-				DFAState next = AddDFAState(dfa, configs, contextCache);
-				if (s0 == null)
-				{
-					AtomicReference<DFAState> reference = useContext ? dfa.s0full : dfa.s0;
-					if (!reference.CompareAndSet(null, next))
-					{
-						next = reference.Get();
-					}
-				}
-				else
-				{
-					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);
-		}
-
-		[Nullable]
-		public 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>
-		public 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;
-				D.prediction = ATN.InvalidAltNumber;
-			}
-			// make sure we use preds
-			return predPredictions;
-		}
-
-		public 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.GetAlt()))
-				{
-					altToPred[c.GetAlt()] = SemanticContext.Or(altToPred[c.GetAlt()], c.GetSemanticContext
-						());
-				}
-			}
-			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;
-		}
-
-		public virtual DFAState.PredPrediction[] GetPredicatePredictions(BitSet ambigAlts
-			, SemanticContext[] altToPred)
-		{
-			IList<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.AddItem(new DFAState.PredPrediction(null, i));
-				}
-				else
-				{
-					if (pred != SemanticContext.None)
-					{
-						containsPredicate = true;
-						pairs.AddItem(new DFAState.PredPrediction(pred, i));
-					}
-				}
-			}
-			if (!containsPredicate)
-			{
-				pairs = null;
-			}
-			//		System.out.println(Arrays.toString(altToPred)+"->"+pairs);
-			return Sharpen.Collections.ToArray(pairs, new DFAState.PredPrediction[pairs.Count
-				]);
-		}
-
-		/// <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
-		/// <code>null</code>
-		/// predicate indicates an alt containing an
-		/// unpredicated config which behaves as "always true."
-		/// </remarks>
-		public virtual BitSet EvalSemanticContext(DFAState.PredPrediction[] predPredictions
-			, ParserRuleContext outerContext, bool complete)
-		{
-			BitSet predictions = new BitSet();
-			foreach (DFAState.PredPrediction pair in predPredictions)
-			{
-				if (pair.pred == null)
-				{
-					predictions.Set(pair.alt);
-					if (!complete)
-					{
-						break;
-					}
-					continue;
-				}
-				bool evaluatedResult = pair.pred.Eval(parser, outerContext);
-				if (debug || dfa_debug)
-				{
-					System.Console.Out.WriteLine("eval pred " + pair + "=" + evaluatedResult);
-				}
-				if (evaluatedResult)
-				{
-					if (debug || dfa_debug)
-					{
-						System.Console.Out.WriteLine("PREDICT " + pair.alt);
-					}
-					predictions.Set(pair.alt);
-					if (!complete)
-					{
-						break;
-					}
-				}
-			}
-			return predictions;
-		}
-
-		protected internal virtual void Closure(ATNConfigSet sourceConfigs, ATNConfigSet 
-			configs, bool collectPredicates, bool hasMoreContext, PredictionContextCache contextCache
-			)
-		{
-			if (contextCache == null)
-			{
-				contextCache = PredictionContextCache.Uncached;
-			}
-			ATNConfigSet currentConfigs = sourceConfigs;
-			ICollection<ATNConfig> closureBusy = new HashSet<ATNConfig>();
-			while (currentConfigs.Count > 0)
-			{
-				ATNConfigSet intermediate = new ATNConfigSet();
-				foreach (ATNConfig config in currentConfigs)
-				{
-					if (optimize_closure_busy && !closureBusy.AddItem(config))
-					{
-						continue;
-					}
-					Closure(config, configs, intermediate, closureBusy, collectPredicates, hasMoreContext
-						, contextCache, 0);
-				}
-				currentConfigs = intermediate;
-			}
-		}
-
-		protected internal virtual void Closure(ATNConfig config, ATNConfigSet configs, ATNConfigSet
-			 intermediate, ICollection<ATNConfig> closureBusy, bool collectPredicates, bool 
-			hasMoreContexts, PredictionContextCache contextCache, int depth)
-		{
-			if (!optimize_closure_busy && !closureBusy.AddItem(config))
-			{
-				return;
-			}
-			// avoid infinite recursion
-			if (config.GetState() is RuleStopState)
-			{
-				// We hit rule end. If we have context info, use it
-				if (!config.GetContext().IsEmpty)
-				{
-					bool hasEmpty = config.GetContext().HasEmpty;
-					int nonEmptySize = config.GetContext().Size - (hasEmpty ? 1 : 0);
-					for (int i = 0; i < nonEmptySize; i++)
-					{
-						PredictionContext newContext = config.GetContext().GetParent(i);
-						// "pop" return state
-						ATNState returnState = atn.states[config.GetContext().GetReturnState(i)];
-						ATNConfig c = ATNConfig.Create(returnState, config.GetAlt(), newContext, config.GetSemanticContext
-							());
-						// 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.SetOuterContextDepth(config.GetOuterContextDepth());
-						System.Diagnostics.Debug.Assert(depth > int.MinValue);
-						if (optimize_closure_busy && c.GetContext().IsEmpty && !closureBusy.AddItem(c))
-						{
-							continue;
-						}
-						Closure(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts
-							, contextCache, depth - 1);
-					}
-					if (!hasEmpty || !hasMoreContexts)
-					{
-						return;
-					}
-					config = config.Transform(config.GetState(), PredictionContext.EmptyLocal);
-				}
-				else
-				{
-					if (!hasMoreContexts)
-					{
-						configs.Add(config, contextCache);
-						return;
-					}
-					else
-					{
-						// else if we have no context info, just chase follow links (if greedy)
-						if (config.GetContext() == PredictionContext.EmptyFull)
-						{
-							// no need to keep full context overhead when we step out
-							config = config.Transform(config.GetState(), PredictionContext.EmptyLocal);
-						}
-					}
-				}
-			}
-			ATNState p = config.GetState();
-			// optimization
-			if (!p.OnlyHasEpsilonTransitions())
-			{
-				configs.Add(config, contextCache);
-			}
-			for (int i_1 = 0; i_1 < p.GetNumberOfOptimizedTransitions(); 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
-					);
-				if (c != null)
-				{
-					if (t is Antlr4.Runtime.Atn.RuleTransition)
-					{
-						if (intermediate != null && !collectPredicates)
-						{
-							intermediate.Add(c, contextCache);
-							continue;
-						}
-					}
-					if (optimize_closure_busy)
-					{
-						bool checkClosure = false;
-						switch (c.GetState().GetStateType())
-						{
-							case ATNState.StarLoopEntry:
-							case ATNState.BlockEnd:
-							case ATNState.LoopEnd:
-							{
-								checkClosure = true;
-								break;
-							}
-
-							case ATNState.PlusBlockStart:
-							{
-								checkClosure = true;
-								break;
-							}
-
-							case ATNState.RuleStop:
-							{
-								checkClosure = c.GetContext().IsEmpty;
-								break;
-							}
-
-							default:
-							{
-								break;
-								break;
-							}
-						}
-						if (checkClosure && !closureBusy.AddItem(c))
-						{
-							continue;
-						}
-					}
-					int newDepth = depth;
-					if (config.GetState() 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.
-						c.SetOuterContextDepth(c.GetOuterContextDepth() + 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.GetContext
-								())))
-							{
-								System.Diagnostics.Debug.Assert(c.GetContext() == config.GetContext());
-								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.GetContext(
-										)))
-									{
-										// make sure the SLL config "dips into the outer context" or prediction may not fall back to LL on conflict
-										c.SetOuterContextDepth(c.GetOuterContextDepth() + 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);
-				}
-			}
-		}
-
-		[NotNull]
-		public virtual string GetRuleName(int index)
-		{
-			if (parser != null && index >= 0)
-			{
-				return parser.GetRuleNames()[index];
-			}
-			return "<rule " + index + ">";
-		}
-
-		[Nullable]
-		public virtual ATNConfig GetEpsilonTarget(ATNConfig config, Transition t, bool collectPredicates
-			, bool inContext, PredictionContextCache contextCache)
-		{
-			switch (t.SerializationType)
-			{
-				case Transition.Rule:
-				{
-					return RuleTransition(config, (Antlr4.Runtime.Atn.RuleTransition)t, contextCache);
-				}
-
-				case Transition.Precedence:
-				{
-					return PrecedenceTransition(config, (PrecedencePredicateTransition)t, collectPredicates
-						, inContext);
-				}
-
-				case Transition.Predicate:
-				{
-					return PredTransition(config, (PredicateTransition)t, collectPredicates, inContext
-						);
-				}
-
-				case Transition.Action:
-				{
-					return ActionTransition(config, (Antlr4.Runtime.Atn.ActionTransition)t);
-				}
-
-				case Transition.Epsilon:
-				{
-					return config.Transform(t.target);
-				}
-
-				default:
-				{
-					return null;
-					break;
-				}
-			}
-		}
-
-		[NotNull]
-		public virtual ATNConfig ActionTransition(ATNConfig config, Antlr4.Runtime.Atn.ActionTransition
-			 t)
-		{
-			return config.Transform(t.target);
-		}
-
-		[Nullable]
-		public virtual ATNConfig PrecedenceTransition(ATNConfig config, PrecedencePredicateTransition
-			 pt, bool collectPredicates, bool inContext)
-		{
-			ATNConfig c = null;
-			if (collectPredicates && inContext)
-			{
-				SemanticContext newSemCtx = SemanticContext.And(config.GetSemanticContext(), pt.GetPredicate
-					());
-				c = config.Transform(pt.target, newSemCtx);
-			}
-			else
-			{
-				c = config.Transform(pt.target);
-			}
-			return c;
-		}
-
-		[Nullable]
-		public virtual ATNConfig PredTransition(ATNConfig config, PredicateTransition pt, 
-			bool collectPredicates, bool inContext)
-		{
-			ATNConfig c;
-			if (collectPredicates && (!pt.isCtxDependent || (pt.isCtxDependent && inContext)))
-			{
-				SemanticContext newSemCtx = SemanticContext.And(config.GetSemanticContext(), pt.GetPredicate
-					());
-				c = config.Transform(pt.target, newSemCtx);
-			}
-			else
-			{
-				c = config.Transform(pt.target);
-			}
-			return c;
-		}
-
-		[NotNull]
-		public 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.GetContext())))
-			{
-				newContext = config.GetContext();
-			}
-			else
-			{
-				if (contextCache != null)
-				{
-					newContext = contextCache.GetChild(config.GetContext(), returnState.stateNumber);
-				}
-				else
-				{
-					newContext = config.GetContext().GetChild(returnState.stateNumber);
-				}
-			}
-			return config.Transform(t.target, newContext);
-		}
-
-		private sealed class _IComparer_1557 : IComparer<ATNConfig>
-		{
-			public _IComparer_1557()
-			{
-			}
-
-			public int Compare(ATNConfig o1, ATNConfig o2)
-			{
-				int diff = o1.GetState().GetNonStopStateNumber() - o2.GetState().GetNonStopStateNumber
-					();
-				if (diff != 0)
-				{
-					return diff;
-				}
-				diff = o1.GetAlt() - o2.GetAlt();
-				if (diff != 0)
-				{
-					return diff;
-				}
-				return 0;
-			}
-		}
-
-		private static readonly IComparer<ATNConfig> StateAltSortComparator = new _IComparer_1557
-			();
-
-		private BitSet IsConflicted(ATNConfigSet configset, PredictionContextCache contextCache
-			)
-		{
-			if (configset.GetUniqueAlt() != ATN.InvalidAltNumber || configset.Count <= 1)
-			{
-				return null;
-			}
-			IList<ATNConfig> configs = new List<ATNConfig>(configset);
-			configs.Sort(StateAltSortComparator);
-			bool exact = !configset.GetDipsIntoOuterContext() && predictionMode == PredictionMode
-				.LlExactAmbigDetection;
-			BitSet alts = new BitSet();
-			int minAlt = configs[0].GetAlt();
-			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].GetState().GetNonStopStateNumber();
-			for (int i = 0; i < configs.Count; i++)
-			{
-				ATNConfig config = configs[i];
-				int stateNumber = config.GetState().GetNonStopStateNumber();
-				if (stateNumber != currentState)
-				{
-					if (config.GetAlt() != minAlt)
-					{
-						return null;
-					}
-					currentState = stateNumber;
-				}
-			}
-			BitSet representedAlts = null;
-			if (exact)
-			{
-				currentState = configs[0].GetState().GetNonStopStateNumber();
-				// get the represented alternatives of the first state
-				representedAlts = new BitSet();
-				int maxAlt = minAlt;
-				for (int i_1 = 0; i_1 < configs.Count; i_1++)
-				{
-					ATNConfig config = configs[i_1];
-					if (config.GetState().GetNonStopStateNumber() != currentState)
-					{
-						break;
-					}
-					int alt = config.GetAlt();
-					representedAlts.Set(alt);
-					maxAlt = alt;
-				}
-				// quick check #3:
-				currentState = configs[0].GetState().GetNonStopStateNumber();
-				int currentAlt = minAlt;
-				for (int i_2 = 0; i_2 < configs.Count; i_2++)
-				{
-					ATNConfig config = configs[i_2];
-					int stateNumber = config.GetState().GetNonStopStateNumber();
-					int alt = config.GetAlt();
-					if (stateNumber != currentState)
-					{
-						if (currentAlt != maxAlt)
-						{
-							return null;
-						}
-						currentState = stateNumber;
-						currentAlt = minAlt;
-					}
-					else
-					{
-						if (alt != currentAlt)
-						{
-							if (alt != representedAlts.NextSetBit(currentAlt + 1))
-							{
-								return null;
-							}
-							currentAlt = alt;
-						}
-					}
-				}
-			}
-			currentState = configs[0].GetState().GetNonStopStateNumber();
-			int firstIndexCurrentState = 0;
-			int lastIndexCurrentStateMinAlt = 0;
-			PredictionContext joinedCheckContext = configs[0].GetContext();
-			for (int i_3 = 1; i_3 < configs.Count; i_3++)
-			{
-				ATNConfig config = configs[i_3];
-				if (config.GetAlt() != minAlt)
-				{
-					break;
-				}
-				if (config.GetState().GetNonStopStateNumber() != currentState)
-				{
-					break;
-				}
-				lastIndexCurrentStateMinAlt = i_3;
-				joinedCheckContext = contextCache.Join(joinedCheckContext, configs[i_3].GetContext
-					());
-			}
-			for (int i_4 = lastIndexCurrentStateMinAlt + 1; i_4 < configs.Count; i_4++)
-			{
-				ATNConfig config = configs[i_4];
-				ATNState state = config.GetState();
-				alts.Set(config.GetAlt());
-				if (state.GetNonStopStateNumber() != currentState)
-				{
-					currentState = state.GetNonStopStateNumber();
-					firstIndexCurrentState = i_4;
-					lastIndexCurrentStateMinAlt = i_4;
-					joinedCheckContext = config.GetContext();
-					for (int j = firstIndexCurrentState + 1; j < configs.Count; j++)
-					{
-						ATNConfig config2 = configs[j];
-						if (config2.GetAlt() != minAlt)
-						{
-							break;
-						}
-						if (config2.GetState().GetNonStopStateNumber() != currentState)
-						{
-							break;
-						}
-						lastIndexCurrentStateMinAlt = j;
-						joinedCheckContext = contextCache.Join(joinedCheckContext, config2.GetContext());
-					}
-					i_4 = lastIndexCurrentStateMinAlt;
-					continue;
-				}
-				PredictionContext joinedCheckContext2 = config.GetContext();
-				int currentAlt = config.GetAlt();
-				int lastIndexCurrentStateCurrentAlt = i_4;
-				for (int j_1 = lastIndexCurrentStateCurrentAlt + 1; j_1 < configs.Count; j_1++)
-				{
-					ATNConfig config2 = configs[j_1];
-					if (config2.GetAlt() != currentAlt)
-					{
-						break;
-					}
-					if (config2.GetState().GetNonStopStateNumber() != currentState)
-					{
-						break;
-					}
-					lastIndexCurrentStateCurrentAlt = j_1;
-					joinedCheckContext2 = contextCache.Join(joinedCheckContext2, config2.GetContext()
-						);
-				}
-				i_4 = lastIndexCurrentStateCurrentAlt;
-				if (exact)
-				{
-					if (!joinedCheckContext.Equals(joinedCheckContext2))
-					{
-						return null;
-					}
-				}
-				else
-				{
-					PredictionContext check = contextCache.Join(joinedCheckContext, joinedCheckContext2
-						);
-					if (!joinedCheckContext.Equals(check))
-					{
-						return null;
-					}
-				}
-				if (!exact && optimize_hidden_conflicted_configs)
-				{
-					for (int j = firstIndexCurrentState; j_1 <= lastIndexCurrentStateMinAlt; j_1++)
-					{
-						ATNConfig checkConfig = configs[j_1];
-						if (checkConfig.GetSemanticContext() != SemanticContext.None && !checkConfig.GetSemanticContext
-							().Equals(config.GetSemanticContext()))
-						{
-							continue;
-						}
-						if (joinedCheckContext != checkConfig.GetContext())
-						{
-							PredictionContext check = contextCache.Join(checkConfig.GetContext(), config.GetContext
-								());
-							if (!checkConfig.GetContext().Equals(check))
-							{
-								continue;
-							}
-						}
-						config.SetHidden(true);
-					}
-				}
-			}
-			return alts;
-		}
-
-		protected internal virtual BitSet GetConflictingAltsFromConfigSet(ATNConfigSet configs
-			)
-		{
-			BitSet conflictingAlts = configs.GetConflictingAlts();
-			if (conflictingAlts == null && configs.GetUniqueAlt() != ATN.InvalidAltNumber)
-			{
-				conflictingAlts = new BitSet();
-				conflictingAlts.Set(configs.GetUniqueAlt());
-			}
-			return conflictingAlts;
-		}
-
-		protected internal virtual int ResolveToMinAlt(DFAState D, BitSet conflictingAlts
-			)
-		{
-			// kill dead alts so we don't chase them ever
-			//		killAlts(conflictingAlts, D.configset);
-			D.prediction = conflictingAlts.NextSetBit(0);
-			return D.prediction;
-		}
-
-		[NotNull]
-		public virtual string GetTokenName(int t)
-		{
-			if (t == IToken.Eof)
-			{
-				return "EOF";
-			}
-			if (parser != null && parser.GetTokenNames() != null)
-			{
-				string[] tokensNames = parser.GetTokenNames();
-				if (t >= tokensNames.Length)
-				{
-					System.Console.Error.WriteLine(t + " ttype out of range: " + Arrays.ToString(tokensNames
-						));
-					System.Console.Error.WriteLine(((CommonTokenStream)((ITokenStream)parser.GetInputStream
-						())).GetTokens());
-				}
-				else
-				{
-					return tokensNames[t] + "<" + t + ">";
-				}
-			}
-			return t.ToString();
-		}
-
-		public virtual string GetLookaheadName(ITokenStream input)
-		{
-			return GetTokenName(input.La(1));
-		}
-
-		public virtual void DumpDeadEndConfigs(NoViableAltException nvae)
-		{
-			System.Console.Error.WriteLine("dead end configs: ");
-			foreach (ATNConfig c in nvae.GetDeadEndConfigs())
-			{
-				string trans = "no edges";
-				if (c.GetState().GetNumberOfOptimizedTransitions() > 0)
-				{
-					Transition t = c.GetState().GetOptimizedTransition(0);
-					if (t is AtomTransition)
-					{
-						AtomTransition at = (AtomTransition)t;
-						trans = "Atom " + GetTokenName(at.label);
-					}
-					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);
-			}
-		}
-
-		[NotNull]
-		public virtual NoViableAltException NoViableAlt(ITokenStream input, ParserRuleContext
-			 outerContext, ATNConfigSet configs, int startIndex)
-		{
-			return new NoViableAltException(parser, input, input.Get(startIndex), input.Lt(1)
-				, configs, outerContext);
-		}
-
-		public virtual int GetUniqueAlt(ICollection<ATNConfig> configs)
-		{
-			int alt = ATN.InvalidAltNumber;
-			foreach (ATNConfig c in configs)
-			{
-				if (alt == ATN.InvalidAltNumber)
-				{
-					alt = c.GetAlt();
-				}
-				else
-				{
-					// found first alt
-					if (c.GetAlt() != alt)
-					{
-						return ATN.InvalidAltNumber;
-					}
-				}
-			}
-			return alt;
-		}
-
-		public virtual bool ConfigWithAltAtStopState(ICollection<ATNConfig> configs, int 
-			alt)
-		{
-			foreach (ATNConfig c in configs)
-			{
-				if (c.GetAlt() == alt)
-				{
-					if (c.GetState() is RuleStopState)
-					{
-						return true;
-					}
-				}
-			}
-			return false;
-		}
-
-		[NotNull]
-		protected internal virtual DFAState AddDFAEdge(DFA dfa, DFAState fromState, int t
-			, IntegerList contextTransitions, ATNConfigSet toConfigs, PredictionContextCache
-			 contextCache)
-		{
-			System.Diagnostics.Debug.Assert(dfa.IsContextSensitive() || contextTransitions ==
-				 null || contextTransitions.IsEmpty());
-			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>
-		[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.AddItem(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.SetOutermostConfigSet(true);
-				return AddDFAState(dfa, configs, contextCache);
-			}
-		}
-
-		/// <summary>See comment on LexerInterpreter.addDFAState.</summary>
-		/// <remarks>See comment on LexerInterpreter.addDFAState.</remarks>
-		[NotNull]
-		protected internal virtual DFAState AddDFAState(DFA dfa, ATNConfigSet configs, PredictionContextCache
-			 contextCache)
-		{
-			if (!configs.IsReadOnly())
-			{
-				configs.OptimizeConfigs(this);
-			}
-			DFAState proposed = CreateDFAState(configs);
-			DFAState existing = dfa.states.Get(proposed);
-			if (existing != null)
-			{
-				return existing;
-			}
-			if (!configs.IsReadOnly())
-			{
-				if (configs.GetConflictingAlts() == null)
-				{
-					configs.SetConflictingAlts(IsConflicted(configs, contextCache));
-					if (optimize_hidden_conflicted_configs && configs.GetConflictingAlts() != null)
-					{
-						int size = configs.Count;
-						configs.StripHiddenConfigs();
-						if (configs.Count < size)
-						{
-							proposed = CreateDFAState(configs);
-							existing = dfa.states.Get(proposed);
-							if (existing != null)
-							{
-								return existing;
-							}
-						}
-					}
-				}
-			}
-			DFAState newState = CreateDFAState(configs.Clone(true));
-			DecisionState decisionState = atn.GetDecisionState(dfa.decision);
-			int predictedAlt = GetUniqueAlt(configs);
-			if (predictedAlt != ATN.InvalidAltNumber)
-			{
-				newState.isAcceptState = true;
-				newState.prediction = predictedAlt;
-			}
-			else
-			{
-				if (configs.GetConflictingAlts() != null)
-				{
-					newState.isAcceptState = true;
-					newState.prediction = ResolveToMinAlt(newState, newState.configs.GetConflictingAlts
-						());
-				}
-			}
-			if (newState.isAcceptState && configs.HasSemanticContext())
-			{
-				PredicateDFAState(newState, configs, decisionState.GetNumberOfTransitions());
-			}
-			DFAState added = dfa.AddState(newState);
-			if (debug && added == newState)
-			{
-				System.Console.Out.WriteLine("adding new DFA state: " + newState);
-			}
-			return added;
-		}
-
-		[NotNull]
-		protected internal virtual DFAState CreateDFAState(ATNConfigSet configs)
-		{
-			return new DFAState(configs, -1, atn.maxTokenType);
-		}
-
-		//	public void reportConflict(int startIndex, int stopIndex,
-		//							   @NotNull IntervalSet alts,
-		//							   @NotNull ATNConfigSet configs)
-		//	{
-		//		if ( debug || retry_debug ) {
-		//			System.out.println("reportConflict "+alts+":"+configs+
-		//							   ", input="+parser.getInputString(startIndex, stopIndex));
-		//		}
-		//		if ( parser!=null ) parser.getErrorHandler().reportConflict(parser, startIndex, stopIndex, alts, configs);
-		//	}
-		public virtual void ReportAttemptingFullContext(DFA dfa, SimulatorState initialState
-			, int startIndex, int stopIndex)
-		{
-			if (debug || retry_debug)
-			{
-				Interval interval = Interval.Of(startIndex, stopIndex);
-				System.Console.Out.WriteLine("reportAttemptingFullContext decision=" + dfa.decision
-					 + ":" + initialState.s0.configs + ", input=" + ((ITokenStream)parser.GetInputStream
-					()).GetText(interval));
-			}
-			if (parser != null)
-			{
-				((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportAttemptingFullContext
-					(parser, dfa, startIndex, stopIndex, initialState);
-			}
-		}
-
-		public virtual void ReportContextSensitivity(DFA dfa, SimulatorState acceptState, 
-			int startIndex, int stopIndex)
-		{
-			if (debug || retry_debug)
-			{
-				Interval interval = Interval.Of(startIndex, stopIndex);
-				System.Console.Out.WriteLine("reportContextSensitivity decision=" + dfa.decision 
-					+ ":" + acceptState.s0.configs + ", input=" + ((ITokenStream)parser.GetInputStream
-					()).GetText(interval));
-			}
-			if (parser != null)
-			{
-				((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportContextSensitivity
-					(parser, dfa, startIndex, stopIndex, acceptState);
-			}
-		}
-
-		/// <summary>If context sensitive parsing, we know it's ambiguity not conflict</summary>
-		public virtual void ReportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex
-			, BitSet ambigAlts, ATNConfigSet configs)
-		{
-			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.Console.Out.WriteLine("reportAmbiguity " + ambigAlts + ":" + configs + ", input="
-					 + ((ITokenStream)parser.GetInputStream()).GetText(interval));
-			}
-			if (parser != null)
-			{
-				((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportAmbiguity(parser, 
-					dfa, startIndex, stopIndex, 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.GetNumberOfTransitions() == 1 && state.Transition
-					(0).SerializationType == Transition.Rule);
-				Antlr4.Runtime.Atn.RuleTransition transition = (Antlr4.Runtime.Atn.RuleTransition
-					)state.Transition(0);
-				if (!transition.tailCall)
-				{
-					break;
-				}
-				context = ((ParserRuleContext)context.Parent);
-			}
-			return context;
-		}
-	}
+    /// <summary>The embodiment of the adaptive LL(*) parsing strategy.</summary>
+    /// <remarks>
+    /// The embodiment of the adaptive LL(*) 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
+    /// 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 entry rule.  For
+    /// example, if prediction occurs without invoking another rule's
+    /// ATN, there are no context stacks in the configurations. When this
+    /// 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(*)).
+    /// So, we simply retry the ATN simulation again, this time
+    /// using full outer context and filling a dummy DFA (to avoid
+    /// polluting the context insensitive DFA). Configuration context
+    /// stacks will be the full invocation stack 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.) We create a special DFA accept state
+    /// that maps rule context to a predicted alternative. That is the
+    /// only modification needed to handle full LL(*) prediction. In
+    /// general, full context prediction will use more lookahead than
+    /// necessary, but it pays to share the same DFA. For a schedule
+    /// proof that full context prediction uses that most the same amount
+    /// of lookahead as a context insensitive prediction, see the comment
+    /// on method retryWithContext().
+    /// So, the strategy is complex because we bounce back and forth from
+    /// the ATN to the DFA, simultaneously performing predictions and
+    /// extending the DFA according to previously unseen input
+    /// sequences. The retry with full context is a recursive call to the
+    /// same function naturally because it does the same thing, just with
+    /// a different initial context. The problem is, that we need to pass
+    /// in a "full context mode" parameter so that it knows to report
+    /// conflicts differently. It also knows not to do a retry, to avoid
+    /// infinite recursion, if it is already using full context.
+    /// Retry a simulation using full outer context.
+    /// One of the key assumptions here is that using full context
+    /// can use at most the same amount of input as a simulation
+    /// that is not useful context (i.e., it uses all possible contexts
+    /// that could invoke our entry rule. I believe that this is true
+    /// and the proof might go like this.
+    /// THEOREM:  The amount of input consumed during a full context
+    /// simulation is at most the amount of input consumed during a
+    /// non full context simulation.
+    /// PROOF: Let D be the DFA state at which non-context simulation
+    /// terminated. That means that D does not have a configuration for
+    /// which we can legally pursue more input. (It is legal to work only
+    /// on configurations for which there is no conflict with another
+    /// configuration.) Now we restrict ourselves to following ATN edges
+    /// associated with a single context. Choose any DFA state D' along
+    /// the path (same input) to D. That state has either the same number
+    /// of configurations or fewer. (If the number of configurations is
+    /// the same, then we have degenerated to the non-context case.) Now
+    /// imagine that we restrict to following edges associated with
+    /// another single context and that we reach DFA state D'' for the
+    /// same amount of input as D'. The non-context simulation merges D'
+    /// and D''. The union of the configuration sets either has the same
+    /// number of configurations as both D' and D'' or it has more. If it
+    /// has the same number, we are no worse off and the merge does not
+    /// force us to look for more input than we would otherwise have to
+    /// do. If the union has more configurations, it can introduce
+    /// conflicts but not new alternatives--we cannot conjure up alternatives
+    /// by computing closure on the DFA state.  Here are the cases for
+    /// D' union D'':
+    /// 1. No increase in configurations, D' = D''
+    /// 2. Add configuration that introduces a new alternative number.
+    /// This cannot happen because no new alternatives are introduced
+    /// while computing closure, even during start state computation.
+    /// 3. D'' adds a configuration that does not conflict with any
+    /// configuration in D'.  Simulating without context would then have
+    /// forced us to use more lookahead than D' (full context) alone.
+    /// 3. D'' adds a configuration that introduces a conflict with a
+    /// configuration in D'. There are 2 cases:
+    /// a. The conflict does not cause termination (D' union D''
+    /// is added to the work list). Again no context simulation requires
+    /// more input.
+    /// b. The conflict does cause termination, but this cannot happen.
+    /// By definition, we know that with ALL contexts merged we
+    /// don't terminate until D and D' uses less input than D. Therefore
+    /// no context simulation requires more input than full context
+    /// simulation.
+    /// We have covered all the cases and there is never a situation where
+    /// a single, full context simulation requires more input than a
+    /// no context simulation.
+    /// I spent a bunch of time thinking about this problem after finding
+    /// a case where context-sensitive ATN simulation looks beyond what they
+    /// no context simulation uses. the no context simulation for if then else
+    /// stops at the else whereas full context scans through to the end of the
+    /// statement to decide that the "else statement" clause is ambiguous. And
+    /// sometimes it is not ambiguous! Ok, I made an untrue assumption in my
+    /// proof which I won't bother going to. the important thing is what I'm
+    /// going to do about it. I thought I had a simple answer, but nope. It
+    /// turns out that the if then else case is perfect example of something
+    /// that has the following characteristics:
+    /// no context conflicts at k=1
+    /// full context at k=(1 + length of statement) can be both ambiguous and not
+    /// ambiguous depending on the input, though I think from different contexts.
+    /// But, the good news is that the k=1 case is a special case in that
+    /// SLL(1) and LL(1) have exactly the same power so we can conclude that
+    /// conflicts at k=1 are true ambiguities and we do not need to pursue
+    /// context-sensitive parsing. That covers a huge number of cases
+    /// including the if then else clause and the predicated precedence
+    /// parsing mechanism. whew! because that could be extremely expensive if
+    /// we had to do context.
+    /// Further, there is no point in doing full context if none of the
+    /// configurations dip into the outer context. This nicely handles cases
+    /// such 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.
+    /// So, we now cover what I hope is the vast majority of the cases (in
+    /// particular the very important precedence parsing case). Anything that
+    /// needs k&gt;1 and dips into the outer context requires a full context
+    /// retry. In this case, I'm going to start out with a brain-dead solution
+    /// which is to mark the DFA state as context-sensitive when I get a
+    /// conflict. Any further DFA simulation that reaches that state will
+    /// launch an ATN simulation to get the prediction, without updating the
+    /// DFA or storing any context information. Later, I can make this more
+    /// efficient, but at least in this case I can guarantee that it will
+    /// always do the right thing. We are not making any assumptions about
+    /// lookahead depth.
+    /// Ok, writing this up so I can put in a comment.
+    /// Upon conflict in the no context simulation:
+    /// if k=1, report ambiguity and resolve to the minimum conflicting alternative
+    /// if k=1 and predicates, no report and include the predicate to
+    /// predicted alternative map in the DFA state
+    /// if k=* and we did not dip into the outer context, report ambiguity
+    /// and resolve to minimum conflicting alternative
+    /// if k&gt;1 and we dip into outer context, retry with full context
+    /// if conflict, report ambiguity and resolve to minimum conflicting
+    /// alternative, mark DFA as context-sensitive
+    /// If no conflict, report ctx sensitivity and mark DFA as context-sensitive
+    /// Technically, if full context k is less than no context k, we can
+    /// reuse the conflicting DFA state so we don't have to create special
+    /// DFA paths branching from context, but we can leave that for
+    /// optimization later if necessary.
+    /// if non-greedy, no report and resolve to the exit alternative
+    /// 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>
+    public class ParserATNSimulator : ATNSimulator
+    {
+        public const bool debug = false;
+
+        public const bool dfa_debug = false;
+
+        public const bool retry_debug = false;
+
+        private PredictionMode predictionMode = PredictionMode.Ll;
+
+        public bool force_global_context = false;
+
+        public bool always_try_local_context = true;
+
+        public bool optimize_unique_closure = true;
+
+        public bool optimize_ll1 = true;
+
+        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;
+
+        public static bool optimize_closure_busy = true;
+
+        [Nullable]
+        protected internal readonly Parser parser;
+
+        /// <summary>
+        /// When
+        /// <code>true</code>
+        /// , ambiguous alternatives are reported when they are
+        /// encountered within
+        /// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)
+        ///     ">ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)
+        ///     </see>
+        /// . When
+        /// <code>false</code>
+        /// , these messages
+        /// are suppressed. The default is
+        /// <code>false</code>
+        /// .
+        /// <p>
+        /// When messages about ambiguous alternatives are not required, setting this
+        /// to
+        /// <code>false</code>
+        /// 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;
+
+        /// <summary>Testing only!</summary>
+        public ParserATNSimulator(ATN atn) : this(null, atn)
+        {
+        }
+
+        public ParserATNSimulator(Parser parser, ATN atn) : base(atn)
+        {
+            this.parser = parser;
+        }
+
+        [NotNull]
+        public PredictionMode GetPredictionMode()
+        {
+            return predictionMode;
+        }
+
+        public void SetPredictionMode(PredictionMode predictionMode)
+        {
+            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.IsEmpty())
+            {
+                int ll_1 = input.La(1);
+                if (ll_1 >= 0 && ll_1 <= short.MaxValue)
+                {
+                    int key = (decision << 16) + ll_1;
+                    int alt = atn.LL1Table.Get(key);
+                    if (alt != null)
+                    {
+                        return alt;
+                    }
+                }
+            }
+            if (force_global_context)
+            {
+                useContext = true;
+            }
+            else
+            {
+                if (!always_try_local_context)
+                {
+                    useContext |= dfa != null && dfa.IsContextSensitive();
+                }
+            }
+            userWantsCtxSensitive = useContext || (predictionMode != PredictionMode.Sll && outerContext
+                 != null && !atn.decisionToState[decision].sll);
+            if (outerContext == null)
+            {
+                outerContext = ParserRuleContext.EmptyContext();
+            }
+            SimulatorState state = null;
+            if (!dfa.IsEmpty())
+            {
+                state = GetStartState(dfa, input, outerContext, useContext);
+            }
+            if (state == null)
+            {
+                return PredictATN(dfa, input, outerContext, useContext);
+            }
+            else
+            {
+                //dump(dfa);
+                // start with the DFA
+                int m = input.Mark();
+                int index = input.Index;
+                try
+                {
+                    int alt = ExecDFA(dfa, input, index, state);
+                    return alt;
+                }
+                finally
+                {
+                    input.Seek(index);
+                    input.Release(m);
+                }
+            }
+        }
+
+        public virtual SimulatorState GetStartState(DFA dfa, ITokenStream input, ParserRuleContext
+             outerContext, bool useContext)
+        {
+            if (!useContext)
+            {
+                if (dfa.s0.Get() == null)
+                {
+                    return null;
+                }
+                return new SimulatorState(outerContext, dfa.s0.Get(), false, outerContext);
+            }
+            ParserRuleContext remainingContext = outerContext;
+            System.Diagnostics.Debug.Assert(outerContext != null);
+            DFAState 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);
+        }
+
+        public virtual int PredictATN(DFA dfa, ITokenStream input, ParserRuleContext outerContext
+            , bool useContext)
+        {
+            if (outerContext == null)
+            {
+                outerContext = ParserRuleContext.EmptyContext();
+            }
+            int alt = 0;
+            int m = input.Mark();
+            int index = input.Index;
+            try
+            {
+                SimulatorState state = ComputeStartState(dfa, outerContext, useContext);
+                if (state.s0.isAcceptState)
+                {
+                    return ExecDFA(dfa, input, index, state);
+                }
+                else
+                {
+                    alt = ExecATN(dfa, input, index, state);
+                }
+            }
+            catch (NoViableAltException nvae)
+            {
+                throw;
+            }
+            finally
+            {
+                input.Seek(index);
+                input.Release(m);
+            }
+            return alt;
+        }
+
+        public virtual int ExecDFA(DFA dfa, ITokenStream input, int startIndex, SimulatorState
+             state)
+        {
+            ParserRuleContext outerContext = state.outerContext;
+            DFAState acceptState = null;
+            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);
+                        }
+                        remainingOuterContext = ((ParserRuleContext)remainingOuterContext.Parent);
+                        s = next;
+                    }
+                }
+                if (s.isAcceptState)
+                {
+                    if (s.predicates != null)
+                    {
+                    }
+                    acceptState = s;
+                    // 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(!s.isAcceptState);
+                // if no edge, pop over to ATN interpreter, update DFA and return
+                DFAState target = s.GetTarget(t);
+                if (target == null)
+                {
+                    if (dfa_debug && t >= 0)
+                    {
+                        System.Console.Out.WriteLine("no edge for " + parser.GetTokenNames()[t]);
+                    }
+                    int alt;
+                    SimulatorState initialState = new SimulatorState(outerContext, s, state.useContext
+                        , remainingOuterContext);
+                    alt = ExecATN(dfa, input, startIndex, initialState);
+                    // this adds edge even if next state is accept for
+                    // same alt; e.g., s0-A->:s1=>2-B->:s2=>2
+                    // TODO: This next stuff kills edge, but extra states remain. :(
+                    if (s.isAcceptState && alt != -1)
+                    {
+                        DFAState d = s.GetTarget(input.La(1));
+                        if (d.isAcceptState && d.prediction == s.prediction)
+                        {
+                            // we can carve it out.
+                            s.SetTarget(input.La(1), Error);
+                        }
+                    }
+                    // IGNORE really not error
+                    //dump(dfa);
+                    // action already executed
+                    return alt;
+                }
+                else
+                {
+                    // we've updated DFA, exec'd action, and have our deepest answer
+                    if (target == Error)
+                    {
+                        throw NoViableAlt(input, outerContext, s.configs, startIndex);
+                    }
+                }
+                s = target;
+                if (!s.isAcceptState && t != IIntStream.Eof)
+                {
+                    input.Consume();
+                    t = input.La(1);
+                }
+            }
+            //		if ( acceptState==null ) {
+            //			if ( debug ) System.out.println("!!! no viable alt in dfa");
+            //			return -1;
+            //		}
+            if (acceptState.configs.GetConflictingAlts() != null)
+            {
+                if (dfa.atnStartState is DecisionState)
+                {
+                    if (!userWantsCtxSensitive || !acceptState.configs.GetDipsIntoOuterContext() || (
+                        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
+                        if (acceptState.predicates != null)
+                        {
+                            int conflictIndex = input.Index;
+                            if (conflictIndex != startIndex)
+                            {
+                                input.Seek(startIndex);
+                            }
+                            BitSet predictions = EvalSemanticContext(s.predicates, outerContext, true);
+                            if (predictions.Cardinality() == 1)
+                            {
+                                return predictions.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 fullContextState = ComputeStartState(dfa, outerContext, true);
+                            ReportAttemptingFullContext(dfa, fullContextState, 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
+            if (s.predicates != null)
+            {
+                int stopIndex = input.Index;
+                if (startIndex != stopIndex)
+                {
+                    input.Seek(startIndex);
+                }
+                BitSet alts = EvalSemanticContext(s.predicates, outerContext, reportAmbiguities &&
+                     predictionMode == 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, alts, s.configs);
+                        return alts.NextSetBit(0);
+                        break;
+                    }
+                }
+            }
+            return acceptState.prediction;
+        }
+
+        /// <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>
+        public virtual int ExecATN(DFA dfa, ITokenStream input, int startIndex, SimulatorState
+             initialState)
+        {
+            ParserRuleContext outerContext = initialState.outerContext;
+            bool useContext = initialState.useContext;
+            int t = input.La(1);
+            DecisionState decState = atn.GetDecisionState(dfa.decision);
+            SimulatorState previous = initialState;
+            PredictionContextCache contextCache = new PredictionContextCache();
+            while (true)
+            {
+                // while more work
+                SimulatorState nextState = ComputeReachSet(dfa, previous, t, contextCache);
+                if (nextState == null)
+                {
+                    return HandleNoViableAlt(input, startIndex, previous);
+                }
+                DFAState D = nextState.s0;
+                ATNConfigSet reach = D.configs;
+                // predicted alt => accept state
+                System.Diagnostics.Debug.Assert(D.isAcceptState || GetUniqueAlt(reach) == ATN.InvalidAltNumber
+                    );
+                // conflicted => accept state
+                System.Diagnostics.Debug.Assert(D.isAcceptState || D.configs.GetConflictingAlts()
+                     == null);
+                if (D.isAcceptState)
+                {
+                    int predictedAlt = reach.GetConflictingAlts() == null ? GetUniqueAlt(reach) : ATN
+                        .InvalidAltNumber;
+                    if (predictedAlt != ATN.InvalidAltNumber)
+                    {
+                        if (optimize_ll1 && input.Index == startIndex && nextState.outerContext == nextState
+                            .remainingOuterContext && dfa.decision >= 0 && !D.configs.HasSemanticContext(
+                            ))
+                        {
+                            if (t >= 0 && t <= short.MaxValue)
+                            {
+                                int key = (dfa.decision << 16) + t;
+                                atn.LL1Table.Put(key, predictedAlt);
+                            }
+                        }
+                        if (useContext && always_try_local_context)
+                        {
+                            ReportContextSensitivity(dfa, nextState, startIndex, input.Index);
+                        }
+                    }
+                    else
+                    {
+                        if (D.configs.GetConflictingAlts() != null)
+                        {
+                            predictedAlt = D.prediction;
+                            //						int k = input.index() - startIndex + 1; // how much input we used
+                            //						System.out.println("used k="+k);
+                            if (!userWantsCtxSensitive || !D.configs.GetDipsIntoOuterContext() || (treat_sllk1_conflict_as_ambiguity
+                                 && input.Index == startIndex))
+                            {
+                                if (reportAmbiguities && !D.configs.HasSemanticContext())
+                                {
+                                    ReportAmbiguity(dfa, D, startIndex, input.Index, D.configs.GetConflictingAlts(), 
+                                        D.configs);
+                                }
+                            }
+                            else
+                            {
+                                System.Diagnostics.Debug.Assert(!useContext);
+                                System.Diagnostics.Debug.Assert(D.isAcceptState);
+                                if (D.configs.HasSemanticContext())
+                                {
+                                    int nalts = decState.GetNumberOfTransitions();
+                                    DFAState.PredPrediction[] predPredictions = D.predicates;
+                                    if (predPredictions != null)
+                                    {
+                                        int conflictIndex = input.Index;
+                                        if (conflictIndex != startIndex)
+                                        {
+                                            input.Seek(startIndex);
+                                        }
+                                        // always use complete evaluation here since we'll want to retry with full context if still ambiguous
+                                        BitSet alts = EvalSemanticContext(predPredictions, outerContext, true);
+                                        if (alts.Cardinality() == 1)
+                                        {
+                                            return alts.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);
+                                        }
+                                    }
+                                }
+                                SimulatorState fullContextState = ComputeStartState(dfa, outerContext, true);
+                                if (reportAmbiguities)
+                                {
+                                    ReportAttemptingFullContext(dfa, fullContextState, startIndex, input.Index);
+                                }
+                                input.Seek(startIndex);
+                                return ExecATN(dfa, input, startIndex, fullContextState);
+                            }
+                        }
+                    }
+                    if (D.predicates != null)
+                    {
+                        int stopIndex = input.Index;
+                        if (startIndex != stopIndex)
+                        {
+                            input.Seek(startIndex);
+                        }
+                        BitSet alts = EvalSemanticContext(D.predicates, outerContext, reportAmbiguities &&
+                             predictionMode == PredictionMode.LlExactAmbigDetection);
+                        D.prediction = ATN.InvalidAltNumber;
+                        switch (alts.Cardinality())
+                        {
+                            case 0:
+                            {
+                                throw NoViableAlt(input, outerContext, D.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, D, startIndex, stopIndex, alts, D.configs);
+                                return alts.NextSetBit(0);
+                                break;
+                            }
+                        }
+                    }
+                    return predictedAlt;
+                }
+                previous = nextState;
+                if (t != IIntStream.Eof)
+                {
+                    input.Consume();
+                    t = input.La(1);
+                }
+            }
+        }
+
+        protected internal virtual int HandleNoViableAlt(ITokenStream input, int startIndex
+            , SimulatorState previous)
+        {
+            if (previous.s0 != null)
+            {
+                BitSet alts = new BitSet();
+                foreach (ATNConfig config in previous.s0.configs)
+                {
+                    if (config.GetReachesIntoOuterContext() || config.GetState() is RuleStopState)
+                    {
+                        alts.Set(config.GetAlt());
+                    }
+                }
+                if (!alts.IsEmpty())
+                {
+                    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;
+                    }
+                    remainingGlobalContext = ((ParserRuleContext)remainingGlobalContext.Parent);
+                    s = next;
+                }
+            }
+            System.Diagnostics.Debug.Assert(!s.isAcceptState);
+            if (s.isAcceptState)
+            {
+                return new SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext
+                    );
+            }
+            DFAState s0 = s;
+            DFAState existingTarget = s0 != null ? s0.GetTarget(t) : null;
+            if (existingTarget != null)
+            {
+                return new SimulatorState(previous.outerContext, existingTarget, useContext, remainingGlobalContext
+                    );
+            }
+            IList<ATNConfig> closureConfigs = new List<ATNConfig>(s0.configs);
+            IntegerList contextElements = null;
+            ATNConfigSet reach = new ATNConfigSet();
+            bool stepIntoGlobal;
+            do
+            {
+                bool hasMoreContext = !useContext || remainingGlobalContext != null;
+                if (!hasMoreContext)
+                {
+                    reach.SetOutermostConfigSet(true);
+                }
+                ATNConfigSet reachIntermediate = new ATNConfigSet();
+                IList<ATNConfig> skippedStopStates = null;
+                foreach (ATNConfig c in closureConfigs)
+                {
+                    if (c.GetState() is RuleStopState)
+                    {
+                        System.Diagnostics.Debug.Assert(c.GetContext().IsEmpty);
+                        if (useContext && !c.GetReachesIntoOuterContext() || t == IIntStream.Eof)
+                        {
+                            if (skippedStopStates == null)
+                            {
+                                skippedStopStates = new List<ATNConfig>();
+                            }
+                            skippedStopStates.AddItem(c);
+                        }
+                        continue;
+                    }
+                    int n = c.GetState().GetNumberOfOptimizedTransitions();
+                    for (int ti = 0; ti < n; ti++)
+                    {
+                        // for each optimized transition
+                        Transition trans = c.GetState().GetOptimizedTransition(ti);
+                        ATNState target = GetReachableTarget(c, trans, t);
+                        if (target != null)
+                        {
+                            reachIntermediate.Add(c.Transform(target), contextCache);
+                        }
+                    }
+                }
+                if (optimize_unique_closure && skippedStopStates == null && reachIntermediate.GetUniqueAlt
+                    () != ATN.InvalidAltNumber)
+                {
+                    reachIntermediate.SetOutermostConfigSet(reach.IsOutermostConfigSet());
+                    reach = reachIntermediate;
+                    break;
+                }
+                bool collectPredicates = false;
+                Closure(reachIntermediate, reach, collectPredicates, hasMoreContext, contextCache
+                    );
+                stepIntoGlobal = reach.GetDipsIntoOuterContext();
+                if (t == IIntStream.Eof)
+                {
+                    reach = RemoveAllConfigsNotInRuleStopState(reach, contextCache);
+                }
+                if (skippedStopStates != null && (!useContext || !PredictionMode.HasConfigInRuleStopState
+                    (reach)))
+                {
+                    System.Diagnostics.Debug.Assert(!skippedStopStates.IsEmpty());
+                    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 IntegerList();
+                    }
+                    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.Set(i, closureConfigs[i].AppendContext(nextContextElement, contextCache
+                                ));
+                        }
+                    }
+                }
+            }
+            while (useContext && stepIntoGlobal);
+            if (reach.IsEmpty())
+            {
+                return null;
+            }
+            DFAState dfaState = null;
+            if (s0 != null)
+            {
+                dfaState = AddDFAEdge(dfa, s0, t, contextElements, reach, contextCache);
+            }
+            System.Diagnostics.Debug.Assert(!useContext || !dfaState.configs.GetDipsIntoOuterContext
+                ());
+            return new SimulatorState(previous.outerContext, dfaState, useContext, remainingGlobalContext
+                );
+        }
+
+        /// <summary>
+        /// Return a configuration set containing only the configurations from
+        /// <code>configs</code>
+        /// which are in a
+        /// <see cref="RuleStopState">RuleStopState</see>
+        /// . If all
+        /// configurations in
+        /// <code>configs</code>
+        /// are already in a rule stop state, this
+        /// method simply returns
+        /// <code>configs</code>
+        /// .
+        /// </summary>
+        /// <param name="configs">the configuration set to update</param>
+        /// <param name="contextCache">
+        /// the
+        /// <see cref="PredictionContext">PredictionContext</see>
+        /// cache
+        /// </param>
+        /// <returns>
+        /// 
+        /// <code>configs</code>
+        /// if all configurations in
+        /// <code>configs</code>
+        /// are in a
+        /// rule stop state, otherwise return a new configuration set containing only
+        /// the configurations from
+        /// <code>configs</code>
+        /// which are in a rule stop state
+        /// </returns>
+        [NotNull]
+        protected internal virtual ATNConfigSet RemoveAllConfigsNotInRuleStopState(ATNConfigSet
+             configs, PredictionContextCache contextCache)
+        {
+            if (PredictionMode.AllConfigsInRuleStopStates(configs))
+            {
+                return configs;
+            }
+            ATNConfigSet result = new ATNConfigSet();
+            foreach (ATNConfig config in configs)
+            {
+                if (!(config.GetState() is RuleStopState))
+                {
+                    continue;
+                }
+                result.Add(config, contextCache);
+            }
+            return result;
+        }
+
+        [NotNull]
+        public virtual SimulatorState ComputeStartState(DFA dfa, ParserRuleContext globalContext
+            , bool useContext)
+        {
+            DFAState s0 = useContext ? dfa.s0full.Get() : dfa.s0.Get();
+            if (s0 != null)
+            {
+                if (!useContext)
+                {
+                    return new SimulatorState(globalContext, s0, useContext, globalContext);
+                }
+                s0.SetContextSensitive(atn);
+            }
+            int decision = dfa.decision;
+            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)
+            {
+                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.GetNumberOfTransitions();
+                for (int ti = 0; ti < n; ti++)
+                {
+                    // for each transition
+                    ATNState target = p.Transition(ti).target;
+                    reachIntermediate.AddItem(ATNConfig.Create(target, ti + 1, initialContext));
+                }
+                bool hasMoreContext = remainingGlobalContext != null;
+                if (!hasMoreContext)
+                {
+                    configs.SetOutermostConfigSet(true);
+                }
+                bool collectPredicates = true;
+                Closure(reachIntermediate, configs, collectPredicates, hasMoreContext, contextCache
+                    );
+                bool stepIntoGlobal = configs.GetDipsIntoOuterContext();
+                DFAState next = AddDFAState(dfa, configs, contextCache);
+                if (s0 == null)
+                {
+                    AtomicReference<DFAState> reference = useContext ? dfa.s0full : dfa.s0;
+                    if (!reference.CompareAndSet(null, next))
+                    {
+                        next = reference.Get();
+                    }
+                }
+                else
+                {
+                    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);
+        }
+
+        [Nullable]
+        public 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>
+        public 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;
+                D.prediction = ATN.InvalidAltNumber;
+            }
+            // make sure we use preds
+            return predPredictions;
+        }
+
+        public 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.GetAlt()))
+                {
+                    altToPred[c.GetAlt()] = SemanticContext.Or(altToPred[c.GetAlt()], c.GetSemanticContext
+                        ());
+                }
+            }
+            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;
+        }
+
+        public virtual DFAState.PredPrediction[] GetPredicatePredictions(BitSet ambigAlts
+            , SemanticContext[] altToPred)
+        {
+            IList<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.AddItem(new DFAState.PredPrediction(null, i));
+                }
+                else
+                {
+                    if (pred != SemanticContext.None)
+                    {
+                        containsPredicate = true;
+                        pairs.AddItem(new DFAState.PredPrediction(pred, i));
+                    }
+                }
+            }
+            if (!containsPredicate)
+            {
+                pairs = null;
+            }
+            //		System.out.println(Arrays.toString(altToPred)+"->"+pairs);
+            return Sharpen.Collections.ToArray(pairs, new DFAState.PredPrediction[pairs.Count
+                ]);
+        }
+
+        /// <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
+        /// <code>null</code>
+        /// predicate indicates an alt containing an
+        /// unpredicated config which behaves as "always true."
+        /// </remarks>
+        public virtual BitSet EvalSemanticContext(DFAState.PredPrediction[] predPredictions
+            , ParserRuleContext outerContext, bool complete)
+        {
+            BitSet predictions = new BitSet();
+            foreach (DFAState.PredPrediction pair in predPredictions)
+            {
+                if (pair.pred == null)
+                {
+                    predictions.Set(pair.alt);
+                    if (!complete)
+                    {
+                        break;
+                    }
+                    continue;
+                }
+                bool evaluatedResult = pair.pred.Eval(parser, outerContext);
+                if (debug || dfa_debug)
+                {
+                    System.Console.Out.WriteLine("eval pred " + pair + "=" + evaluatedResult);
+                }
+                if (evaluatedResult)
+                {
+                    if (debug || dfa_debug)
+                    {
+                        System.Console.Out.WriteLine("PREDICT " + pair.alt);
+                    }
+                    predictions.Set(pair.alt);
+                    if (!complete)
+                    {
+                        break;
+                    }
+                }
+            }
+            return predictions;
+        }
+
+        protected internal virtual void Closure(ATNConfigSet sourceConfigs, ATNConfigSet 
+            configs, bool collectPredicates, bool hasMoreContext, PredictionContextCache 
+            contextCache)
+        {
+            if (contextCache == null)
+            {
+                contextCache = PredictionContextCache.Uncached;
+            }
+            ATNConfigSet currentConfigs = sourceConfigs;
+            ICollection<ATNConfig> closureBusy = new HashSet<ATNConfig>();
+            while (currentConfigs.Count > 0)
+            {
+                ATNConfigSet intermediate = new ATNConfigSet();
+                foreach (ATNConfig config in currentConfigs)
+                {
+                    if (optimize_closure_busy && !closureBusy.AddItem(config))
+                    {
+                        continue;
+                    }
+                    Closure(config, configs, intermediate, closureBusy, collectPredicates, hasMoreContext
+                        , contextCache, 0);
+                }
+                currentConfigs = intermediate;
+            }
+        }
+
+        protected internal virtual void Closure(ATNConfig config, ATNConfigSet configs, ATNConfigSet
+             intermediate, ICollection<ATNConfig> closureBusy, bool collectPredicates, bool
+             hasMoreContexts, PredictionContextCache contextCache, int depth)
+        {
+            if (!optimize_closure_busy && !closureBusy.AddItem(config))
+            {
+                return;
+            }
+            // avoid infinite recursion
+            if (config.GetState() is RuleStopState)
+            {
+                // We hit rule end. If we have context info, use it
+                if (!config.GetContext().IsEmpty)
+                {
+                    bool hasEmpty = config.GetContext().HasEmpty;
+                    int nonEmptySize = config.GetContext().Size - (hasEmpty ? 1 : 0);
+                    for (int i = 0; i < nonEmptySize; i++)
+                    {
+                        PredictionContext newContext = config.GetContext().GetParent(i);
+                        // "pop" return state
+                        ATNState returnState = atn.states[config.GetContext().GetReturnState(i)];
+                        ATNConfig c = ATNConfig.Create(returnState, config.GetAlt(), newContext, config.GetSemanticContext
+                            ());
+                        // 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.SetOuterContextDepth(config.GetOuterContextDepth());
+                        System.Diagnostics.Debug.Assert(depth > int.MinValue);
+                        if (optimize_closure_busy && c.GetContext().IsEmpty && !closureBusy.AddItem(c))
+                        {
+                            continue;
+                        }
+                        Closure(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts
+                            , contextCache, depth - 1);
+                    }
+                    if (!hasEmpty || !hasMoreContexts)
+                    {
+                        return;
+                    }
+                    config = config.Transform(config.GetState(), PredictionContext.EmptyLocal);
+                }
+                else
+                {
+                    if (!hasMoreContexts)
+                    {
+                        configs.Add(config, contextCache);
+                        return;
+                    }
+                    else
+                    {
+                        // else if we have no context info, just chase follow links (if greedy)
+                        if (config.GetContext() == PredictionContext.EmptyFull)
+                        {
+                            // no need to keep full context overhead when we step out
+                            config = config.Transform(config.GetState(), PredictionContext.EmptyLocal);
+                        }
+                    }
+                }
+            }
+            ATNState p = config.GetState();
+            // optimization
+            if (!p.OnlyHasEpsilonTransitions())
+            {
+                configs.Add(config, contextCache);
+            }
+            for (int i_1 = 0; i_1 < p.GetNumberOfOptimizedTransitions(); 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
+                    );
+                if (c != null)
+                {
+                    if (t is Antlr4.Runtime.Atn.RuleTransition)
+                    {
+                        if (intermediate != null && !collectPredicates)
+                        {
+                            intermediate.Add(c, contextCache);
+                            continue;
+                        }
+                    }
+                    if (optimize_closure_busy)
+                    {
+                        bool checkClosure = false;
+                        switch (c.GetState().GetStateType())
+                        {
+                            case ATNState.StarLoopEntry:
+                            case ATNState.BlockEnd:
+                            case ATNState.LoopEnd:
+                            {
+                                checkClosure = true;
+                                break;
+                            }
+
+                            case ATNState.PlusBlockStart:
+                            {
+                                checkClosure = true;
+                                break;
+                            }
+
+                            case ATNState.RuleStop:
+                            {
+                                checkClosure = c.GetContext().IsEmpty;
+                                break;
+                            }
+
+                            default:
+                            {
+                                break;
+                                break;
+                            }
+                        }
+                        if (checkClosure && !closureBusy.AddItem(c))
+                        {
+                            continue;
+                        }
+                    }
+                    int newDepth = depth;
+                    if (config.GetState() 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.
+                        c.SetOuterContextDepth(c.GetOuterContextDepth() + 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.GetContext
+                                ())))
+                            {
+                                System.Diagnostics.Debug.Assert(c.GetContext() == config.GetContext());
+                                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.GetContext(
+                                        )))
+                                    {
+                                        // make sure the SLL config "dips into the outer context" or prediction may not fall back to LL on conflict
+                                        c.SetOuterContextDepth(c.GetOuterContextDepth() + 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);
+                }
+            }
+        }
+
+        [NotNull]
+        public virtual string GetRuleName(int index)
+        {
+            if (parser != null && index >= 0)
+            {
+                return parser.GetRuleNames()[index];
+            }
+            return "<rule " + index + ">";
+        }
+
+        [Nullable]
+        public virtual ATNConfig GetEpsilonTarget(ATNConfig config, Transition t, bool collectPredicates
+            , bool inContext, PredictionContextCache contextCache)
+        {
+            switch (t.SerializationType)
+            {
+                case Transition.Rule:
+                {
+                    return RuleTransition(config, (Antlr4.Runtime.Atn.RuleTransition)t, contextCache);
+                }
+
+                case Transition.Precedence:
+                {
+                    return PrecedenceTransition(config, (PrecedencePredicateTransition)t, collectPredicates
+                        , inContext);
+                }
+
+                case Transition.Predicate:
+                {
+                    return PredTransition(config, (PredicateTransition)t, collectPredicates, inContext
+                        );
+                }
+
+                case Transition.Action:
+                {
+                    return ActionTransition(config, (Antlr4.Runtime.Atn.ActionTransition)t);
+                }
+
+                case Transition.Epsilon:
+                {
+                    return config.Transform(t.target);
+                }
+
+                default:
+                {
+                    return null;
+                    break;
+                }
+            }
+        }
+
+        [NotNull]
+        public virtual ATNConfig ActionTransition(ATNConfig config, Antlr4.Runtime.Atn.ActionTransition
+             t)
+        {
+            return config.Transform(t.target);
+        }
+
+        [Nullable]
+        public virtual ATNConfig PrecedenceTransition(ATNConfig config, PrecedencePredicateTransition
+             pt, bool collectPredicates, bool inContext)
+        {
+            ATNConfig c = null;
+            if (collectPredicates && inContext)
+            {
+                SemanticContext newSemCtx = SemanticContext.And(config.GetSemanticContext(), pt.GetPredicate
+                    ());
+                c = config.Transform(pt.target, newSemCtx);
+            }
+            else
+            {
+                c = config.Transform(pt.target);
+            }
+            return c;
+        }
+
+        [Nullable]
+        public virtual ATNConfig PredTransition(ATNConfig config, PredicateTransition pt, 
+            bool collectPredicates, bool inContext)
+        {
+            ATNConfig c;
+            if (collectPredicates && (!pt.isCtxDependent || (pt.isCtxDependent && inContext)))
+            {
+                SemanticContext newSemCtx = SemanticContext.And(config.GetSemanticContext(), pt.GetPredicate
+                    ());
+                c = config.Transform(pt.target, newSemCtx);
+            }
+            else
+            {
+                c = config.Transform(pt.target);
+            }
+            return c;
+        }
+
+        [NotNull]
+        public 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.GetContext())))
+            {
+                newContext = config.GetContext();
+            }
+            else
+            {
+                if (contextCache != null)
+                {
+                    newContext = contextCache.GetChild(config.GetContext(), returnState.stateNumber);
+                }
+                else
+                {
+                    newContext = config.GetContext().GetChild(returnState.stateNumber);
+                }
+            }
+            return config.Transform(t.target, newContext);
+        }
+
+        private sealed class _IComparer_1557 : IComparer<ATNConfig>
+        {
+            public _IComparer_1557()
+            {
+            }
+
+            public int Compare(ATNConfig o1, ATNConfig o2)
+            {
+                int diff = o1.GetState().GetNonStopStateNumber() - o2.GetState().GetNonStopStateNumber
+                    ();
+                if (diff != 0)
+                {
+                    return diff;
+                }
+                diff = o1.GetAlt() - o2.GetAlt();
+                if (diff != 0)
+                {
+                    return diff;
+                }
+                return 0;
+            }
+        }
+
+        private static readonly IComparer<ATNConfig> StateAltSortComparator = new _IComparer_1557
+            ();
+
+        private BitSet IsConflicted(ATNConfigSet configset, PredictionContextCache contextCache
+            )
+        {
+            if (configset.GetUniqueAlt() != ATN.InvalidAltNumber || configset.Count <= 1)
+            {
+                return null;
+            }
+            IList<ATNConfig> configs = new List<ATNConfig>(configset);
+            configs.Sort(StateAltSortComparator);
+            bool exact = !configset.GetDipsIntoOuterContext() && predictionMode == PredictionMode
+                .LlExactAmbigDetection;
+            BitSet alts = new BitSet();
+            int minAlt = configs[0].GetAlt();
+            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].GetState().GetNonStopStateNumber();
+            for (int i = 0; i < configs.Count; i++)
+            {
+                ATNConfig config = configs[i];
+                int stateNumber = config.GetState().GetNonStopStateNumber();
+                if (stateNumber != currentState)
+                {
+                    if (config.GetAlt() != minAlt)
+                    {
+                        return null;
+                    }
+                    currentState = stateNumber;
+                }
+            }
+            BitSet representedAlts = null;
+            if (exact)
+            {
+                currentState = configs[0].GetState().GetNonStopStateNumber();
+                // get the represented alternatives of the first state
+                representedAlts = new BitSet();
+                int maxAlt = minAlt;
+                for (int i_1 = 0; i_1 < configs.Count; i_1++)
+                {
+                    ATNConfig config = configs[i_1];
+                    if (config.GetState().GetNonStopStateNumber() != currentState)
+                    {
+                        break;
+                    }
+                    int alt = config.GetAlt();
+                    representedAlts.Set(alt);
+                    maxAlt = alt;
+                }
+                // quick check #3:
+                currentState = configs[0].GetState().GetNonStopStateNumber();
+                int currentAlt = minAlt;
+                for (int i_2 = 0; i_2 < configs.Count; i_2++)
+                {
+                    ATNConfig config = configs[i_2];
+                    int stateNumber = config.GetState().GetNonStopStateNumber();
+                    int alt = config.GetAlt();
+                    if (stateNumber != currentState)
+                    {
+                        if (currentAlt != maxAlt)
+                        {
+                            return null;
+                        }
+                        currentState = stateNumber;
+                        currentAlt = minAlt;
+                    }
+                    else
+                    {
+                        if (alt != currentAlt)
+                        {
+                            if (alt != representedAlts.NextSetBit(currentAlt + 1))
+                            {
+                                return null;
+                            }
+                            currentAlt = alt;
+                        }
+                    }
+                }
+            }
+            currentState = configs[0].GetState().GetNonStopStateNumber();
+            int firstIndexCurrentState = 0;
+            int lastIndexCurrentStateMinAlt = 0;
+            PredictionContext joinedCheckContext = configs[0].GetContext();
+            for (int i_3 = 1; i_3 < configs.Count; i_3++)
+            {
+                ATNConfig config = configs[i_3];
+                if (config.GetAlt() != minAlt)
+                {
+                    break;
+                }
+                if (config.GetState().GetNonStopStateNumber() != currentState)
+                {
+                    break;
+                }
+                lastIndexCurrentStateMinAlt = i_3;
+                joinedCheckContext = contextCache.Join(joinedCheckContext, configs[i_3].GetContext
+                    ());
+            }
+            for (int i_4 = lastIndexCurrentStateMinAlt + 1; i_4 < configs.Count; i_4++)
+            {
+                ATNConfig config = configs[i_4];
+                ATNState state = config.GetState();
+                alts.Set(config.GetAlt());
+                if (state.GetNonStopStateNumber() != currentState)
+                {
+                    currentState = state.GetNonStopStateNumber();
+                    firstIndexCurrentState = i_4;
+                    lastIndexCurrentStateMinAlt = i_4;
+                    joinedCheckContext = config.GetContext();
+                    for (int j = firstIndexCurrentState + 1; j < configs.Count; j++)
+                    {
+                        ATNConfig config2 = configs[j];
+                        if (config2.GetAlt() != minAlt)
+                        {
+                            break;
+                        }
+                        if (config2.GetState().GetNonStopStateNumber() != currentState)
+                        {
+                            break;
+                        }
+                        lastIndexCurrentStateMinAlt = j;
+                        joinedCheckContext = contextCache.Join(joinedCheckContext, config2.GetContext());
+                    }
+                    i_4 = lastIndexCurrentStateMinAlt;
+                    continue;
+                }
+                PredictionContext joinedCheckContext2 = config.GetContext();
+                int currentAlt = config.GetAlt();
+                int lastIndexCurrentStateCurrentAlt = i_4;
+                for (int j_1 = lastIndexCurrentStateCurrentAlt + 1; j_1 < configs.Count; j_1++)
+                {
+                    ATNConfig config2 = configs[j_1];
+                    if (config2.GetAlt() != currentAlt)
+                    {
+                        break;
+                    }
+                    if (config2.GetState().GetNonStopStateNumber() != currentState)
+                    {
+                        break;
+                    }
+                    lastIndexCurrentStateCurrentAlt = j_1;
+                    joinedCheckContext2 = contextCache.Join(joinedCheckContext2, config2.GetContext()
+                        );
+                }
+                i_4 = lastIndexCurrentStateCurrentAlt;
+                if (exact)
+                {
+                    if (!joinedCheckContext.Equals(joinedCheckContext2))
+                    {
+                        return null;
+                    }
+                }
+                else
+                {
+                    PredictionContext check = contextCache.Join(joinedCheckContext, joinedCheckContext2
+                        );
+                    if (!joinedCheckContext.Equals(check))
+                    {
+                        return null;
+                    }
+                }
+                if (!exact && optimize_hidden_conflicted_configs)
+                {
+                    for (int j = firstIndexCurrentState; j_1 <= lastIndexCurrentStateMinAlt; j_1++)
+                    {
+                        ATNConfig checkConfig = configs[j_1];
+                        if (checkConfig.GetSemanticContext() != SemanticContext.None && !checkConfig.GetSemanticContext
+                            ().Equals(config.GetSemanticContext()))
+                        {
+                            continue;
+                        }
+                        if (joinedCheckContext != checkConfig.GetContext())
+                        {
+                            PredictionContext check = contextCache.Join(checkConfig.GetContext(), config.GetContext
+                                ());
+                            if (!checkConfig.GetContext().Equals(check))
+                            {
+                                continue;
+                            }
+                        }
+                        config.SetHidden(true);
+                    }
+                }
+            }
+            return alts;
+        }
+
+        protected internal virtual BitSet GetConflictingAltsFromConfigSet(ATNConfigSet configs
+            )
+        {
+            BitSet conflictingAlts = configs.GetConflictingAlts();
+            if (conflictingAlts == null && configs.GetUniqueAlt() != ATN.InvalidAltNumber)
+            {
+                conflictingAlts = new BitSet();
+                conflictingAlts.Set(configs.GetUniqueAlt());
+            }
+            return conflictingAlts;
+        }
+
+        protected internal virtual int ResolveToMinAlt(DFAState D, BitSet conflictingAlts
+            )
+        {
+            // kill dead alts so we don't chase them ever
+            //		killAlts(conflictingAlts, D.configset);
+            D.prediction = conflictingAlts.NextSetBit(0);
+            return D.prediction;
+        }
+
+        [NotNull]
+        public virtual string GetTokenName(int t)
+        {
+            if (t == IToken.Eof)
+            {
+                return "EOF";
+            }
+            if (parser != null && parser.GetTokenNames() != null)
+            {
+                string[] tokensNames = parser.GetTokenNames();
+                if (t >= tokensNames.Length)
+                {
+                    System.Console.Error.WriteLine(t + " ttype out of range: " + Arrays.ToString(tokensNames
+                        ));
+                    System.Console.Error.WriteLine(((CommonTokenStream)((ITokenStream)parser.GetInputStream
+                        ())).GetTokens());
+                }
+                else
+                {
+                    return tokensNames[t] + "<" + t + ">";
+                }
+            }
+            return t.ToString();
+        }
+
+        public virtual string GetLookaheadName(ITokenStream input)
+        {
+            return GetTokenName(input.La(1));
+        }
+
+        public virtual void DumpDeadEndConfigs(NoViableAltException nvae)
+        {
+            System.Console.Error.WriteLine("dead end configs: ");
+            foreach (ATNConfig c in nvae.GetDeadEndConfigs())
+            {
+                string trans = "no edges";
+                if (c.GetState().GetNumberOfOptimizedTransitions() > 0)
+                {
+                    Transition t = c.GetState().GetOptimizedTransition(0);
+                    if (t is AtomTransition)
+                    {
+                        AtomTransition at = (AtomTransition)t;
+                        trans = "Atom " + GetTokenName(at.label);
+                    }
+                    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);
+            }
+        }
+
+        [NotNull]
+        public virtual NoViableAltException NoViableAlt(ITokenStream input, ParserRuleContext
+             outerContext, ATNConfigSet configs, int startIndex)
+        {
+            return new NoViableAltException(parser, input, input.Get(startIndex), input.Lt(1)
+                , configs, outerContext);
+        }
+
+        public virtual int GetUniqueAlt(ICollection<ATNConfig> configs)
+        {
+            int alt = ATN.InvalidAltNumber;
+            foreach (ATNConfig c in configs)
+            {
+                if (alt == ATN.InvalidAltNumber)
+                {
+                    alt = c.GetAlt();
+                }
+                else
+                {
+                    // found first alt
+                    if (c.GetAlt() != alt)
+                    {
+                        return ATN.InvalidAltNumber;
+                    }
+                }
+            }
+            return alt;
+        }
+
+        public virtual bool ConfigWithAltAtStopState(ICollection<ATNConfig> configs, int 
+            alt)
+        {
+            foreach (ATNConfig c in configs)
+            {
+                if (c.GetAlt() == alt)
+                {
+                    if (c.GetState() is RuleStopState)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        [NotNull]
+        protected internal virtual DFAState AddDFAEdge(DFA dfa, DFAState fromState, int t
+            , IntegerList contextTransitions, ATNConfigSet toConfigs, PredictionContextCache
+             contextCache)
+        {
+            System.Diagnostics.Debug.Assert(dfa.IsContextSensitive() || contextTransitions ==
+                 null || contextTransitions.IsEmpty());
+            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>
+        [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.AddItem(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.SetOutermostConfigSet(true);
+                return AddDFAState(dfa, configs, contextCache);
+            }
+        }
+
+        /// <summary>See comment on LexerInterpreter.addDFAState.</summary>
+        /// <remarks>See comment on LexerInterpreter.addDFAState.</remarks>
+        [NotNull]
+        protected internal virtual DFAState AddDFAState(DFA dfa, ATNConfigSet configs, PredictionContextCache
+             contextCache)
+        {
+            if (!configs.IsReadOnly())
+            {
+                configs.OptimizeConfigs(this);
+            }
+            DFAState proposed = CreateDFAState(configs);
+            DFAState existing = dfa.states.Get(proposed);
+            if (existing != null)
+            {
+                return existing;
+            }
+            if (!configs.IsReadOnly())
+            {
+                if (configs.GetConflictingAlts() == null)
+                {
+                    configs.SetConflictingAlts(IsConflicted(configs, contextCache));
+                    if (optimize_hidden_conflicted_configs && configs.GetConflictingAlts() != null)
+                    {
+                        int size = configs.Count;
+                        configs.StripHiddenConfigs();
+                        if (configs.Count < size)
+                        {
+                            proposed = CreateDFAState(configs);
+                            existing = dfa.states.Get(proposed);
+                            if (existing != null)
+                            {
+                                return existing;
+                            }
+                        }
+                    }
+                }
+            }
+            DFAState newState = CreateDFAState(configs.Clone(true));
+            DecisionState decisionState = atn.GetDecisionState(dfa.decision);
+            int predictedAlt = GetUniqueAlt(configs);
+            if (predictedAlt != ATN.InvalidAltNumber)
+            {
+                newState.isAcceptState = true;
+                newState.prediction = predictedAlt;
+            }
+            else
+            {
+                if (configs.GetConflictingAlts() != null)
+                {
+                    newState.isAcceptState = true;
+                    newState.prediction = ResolveToMinAlt(newState, newState.configs.GetConflictingAlts
+                        ());
+                }
+            }
+            if (newState.isAcceptState && configs.HasSemanticContext())
+            {
+                PredicateDFAState(newState, configs, decisionState.GetNumberOfTransitions());
+            }
+            DFAState added = dfa.AddState(newState);
+            if (debug && added == newState)
+            {
+                System.Console.Out.WriteLine("adding new DFA state: " + newState);
+            }
+            return added;
+        }
+
+        [NotNull]
+        protected internal virtual DFAState CreateDFAState(ATNConfigSet configs)
+        {
+            return new DFAState(configs, -1, atn.maxTokenType);
+        }
+
+        //	public void reportConflict(int startIndex, int stopIndex,
+        //							   @NotNull IntervalSet alts,
+        //							   @NotNull ATNConfigSet configs)
+        //	{
+        //		if ( debug || retry_debug ) {
+        //			System.out.println("reportConflict "+alts+":"+configs+
+        //							   ", input="+parser.getInputString(startIndex, stopIndex));
+        //		}
+        //		if ( parser!=null ) parser.getErrorHandler().reportConflict(parser, startIndex, stopIndex, alts, configs);
+        //	}
+        public virtual void ReportAttemptingFullContext(DFA dfa, SimulatorState initialState
+            , int startIndex, int stopIndex)
+        {
+            if (debug || retry_debug)
+            {
+                Interval interval = Interval.Of(startIndex, stopIndex);
+                System.Console.Out.WriteLine("reportAttemptingFullContext decision=" + dfa.decision
+                     + ":" + initialState.s0.configs + ", input=" + ((ITokenStream)parser.GetInputStream
+                    ()).GetText(interval));
+            }
+            if (parser != null)
+            {
+                ((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportAttemptingFullContext
+                    (parser, dfa, startIndex, stopIndex, initialState);
+            }
+        }
+
+        public virtual void ReportContextSensitivity(DFA dfa, SimulatorState acceptState, 
+            int startIndex, int stopIndex)
+        {
+            if (debug || retry_debug)
+            {
+                Interval interval = Interval.Of(startIndex, stopIndex);
+                System.Console.Out.WriteLine("reportContextSensitivity decision=" + dfa.decision 
+                    + ":" + acceptState.s0.configs + ", input=" + ((ITokenStream)parser.GetInputStream
+                    ()).GetText(interval));
+            }
+            if (parser != null)
+            {
+                ((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportContextSensitivity
+                    (parser, dfa, startIndex, stopIndex, acceptState);
+            }
+        }
+
+        /// <summary>If context sensitive parsing, we know it's ambiguity not conflict</summary>
+        public virtual void ReportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex
+            , BitSet ambigAlts, ATNConfigSet configs)
+        {
+            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.Console.Out.WriteLine("reportAmbiguity " + ambigAlts + ":" + configs + ", input="
+                     + ((ITokenStream)parser.GetInputStream()).GetText(interval));
+            }
+            if (parser != null)
+            {
+                ((IParserErrorListener)parser.GetErrorListenerDispatch()).ReportAmbiguity(parser, 
+                    dfa, startIndex, stopIndex, 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.GetNumberOfTransitions() == 1 && state.Transition
+                    (0).SerializationType == Transition.Rule);
+                Antlr4.Runtime.Atn.RuleTransition transition = (Antlr4.Runtime.Atn.RuleTransition
+                    )state.Transition(0);
+                if (!transition.tailCall)
+                {
+                    break;
+                }
+                context = ((ParserRuleContext)context.Parent);
+            }
+            return context;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/PlusBlockStartState.cs b/Antlr4.Runtime/Atn/PlusBlockStartState.cs
index bd91c5fe7..d5c3c7fb6 100644
--- a/Antlr4.Runtime/Atn/PlusBlockStartState.cs
+++ b/Antlr4.Runtime/Atn/PlusBlockStartState.cs
@@ -32,25 +32,25 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>
-	/// Start of
-	/// <code>(A|B|...)+</code>
-	/// 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">PlusLoopbackState</see>
-	/// node is the
-	/// real decision-making note for
-	/// <code>A+</code>
-	/// .
-	/// </summary>
-	public sealed class PlusBlockStartState : BlockStartState
-	{
-		public PlusLoopbackState loopBackState;
+    /// <summary>
+    /// Start of
+    /// <code>(A|B|...)+</code>
+    /// 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">PlusLoopbackState</see>
+    /// node is the
+    /// real decision-making note for
+    /// <code>A+</code>
+    /// .
+    /// </summary>
+    public sealed class PlusBlockStartState : BlockStartState
+    {
+        public PlusLoopbackState loopBackState;
 
-		public override int GetStateType()
-		{
-			return PlusBlockStart;
-		}
-	}
+        public override int GetStateType()
+        {
+            return PlusBlockStart;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/PlusLoopbackState.cs b/Antlr4.Runtime/Atn/PlusLoopbackState.cs
index 6a98bb44b..47759c587 100644
--- a/Antlr4.Runtime/Atn/PlusLoopbackState.cs
+++ b/Antlr4.Runtime/Atn/PlusLoopbackState.cs
@@ -32,19 +32,19 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>
-	/// Decision state for
-	/// <code>A+</code>
-	/// and
-	/// <code>(A|B)+</code>
-	/// .  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 int GetStateType()
-		{
-			return PlusLoopBack;
-		}
-	}
+    /// <summary>
+    /// Decision state for
+    /// <code>A+</code>
+    /// and
+    /// <code>(A|B)+</code>
+    /// .  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 int GetStateType()
+        {
+            return PlusLoopBack;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs b/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
index 29489ca05..7db16ede4 100644
--- a/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
+++ b/Antlr4.Runtime/Atn/PrecedencePredicateTransition.cs
@@ -32,46 +32,46 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public sealed class PrecedencePredicateTransition : AbstractPredicateTransition
-	{
-		public readonly int precedence;
+    /// <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 PrecedencePredicateTransition(ATNState target, int precedence) : base(target
+            )
+        {
+            this.precedence = precedence;
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return Precedence;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Precedence;
+            }
+        }
 
-		public override bool IsEpsilon
-		{
-			get
-			{
-				return true;
-			}
-		}
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return false;
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
 
-		public SemanticContext.PrecedencePredicate GetPredicate()
-		{
-			return new SemanticContext.PrecedencePredicate(precedence);
-		}
+        public SemanticContext.PrecedencePredicate GetPredicate()
+        {
+            return new SemanticContext.PrecedencePredicate(precedence);
+        }
 
-		public override string ToString()
-		{
-			return precedence + " >= _p";
-		}
-	}
+        public override string ToString()
+        {
+            return precedence + " >= _p";
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/PredicateTransition.cs b/Antlr4.Runtime/Atn/PredicateTransition.cs
index 5356561e2..651b3a6f5 100644
--- a/Antlr4.Runtime/Atn/PredicateTransition.cs
+++ b/Antlr4.Runtime/Atn/PredicateTransition.cs
@@ -33,64 +33,64 @@ using 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;
+    /// <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 int predIndex;
 
-		public readonly bool isCtxDependent;
+        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 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 int SerializationType
-		{
-			get
-			{
-				return Predicate;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Predicate;
+            }
+        }
 
-		public override bool IsEpsilon
-		{
-			get
-			{
-				return true;
-			}
-		}
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return false;
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
 
-		public SemanticContext.Predicate GetPredicate()
-		{
-			return new SemanticContext.Predicate(ruleIndex, predIndex, isCtxDependent);
-		}
+        public SemanticContext.Predicate GetPredicate()
+        {
+            return new SemanticContext.Predicate(ruleIndex, predIndex, isCtxDependent);
+        }
 
-		[NotNull]
-		public override string ToString()
-		{
-			return "pred_" + ruleIndex + ":" + predIndex;
-		}
-	}
+        [NotNull]
+        public override string ToString()
+        {
+            return "pred_" + ruleIndex + ":" + predIndex;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/PredictionContext.cs b/Antlr4.Runtime/Atn/PredictionContext.cs
index 6cceb93c2..36cea0e9f 100644
--- a/Antlr4.Runtime/Atn/PredictionContext.cs
+++ b/Antlr4.Runtime/Atn/PredictionContext.cs
@@ -36,516 +36,516 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public abstract class PredictionContext
-	{
-		[NotNull]
-		public static readonly Antlr4.Runtime.Atn.PredictionContext EmptyLocal = EmptyPredictionContext
-			.LocalContext;
+    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;
+        [NotNull]
+        public static readonly Antlr4.Runtime.Atn.PredictionContext EmptyFull = EmptyPredictionContext
+            .FullContext;
 
-		public const int EmptyLocalStateKey = int.MinValue;
+        public const int EmptyLocalStateKey = int.MinValue;
 
-		public const int EmptyFullStateKey = int.MaxValue;
+        public const int EmptyFullStateKey = int.MaxValue;
 
-		private const int InitialHash = 1;
+        private const int InitialHash = 1;
 
-		private const int HashMultiplier = 31;
+        private const int HashMultiplier = 31;
 
-		/// <summary>Stores the computed hash code of this PredictionContext.</summary>
-		/// <remarks>
-		/// Stores the computed hash code of this PredictionContext. The hash code is
-		/// computed in parts to match the following reference algorithm.
-		/// <pre>
-		/// private int referenceHashCode() {
-		/// int returnStateHashCode =
-		/// <see cref="InitialHash">INITIAL_HASH</see>
-		/// ;
-		/// for (int i = 0; i &lt; size(); i++) {
-		/// returnStateHashCode = returnStateHashCode *
-		/// <see cref="HashMultiplier">HASH_MULTIPLIER</see>
-		/// ^ getReturnState(i);
-		/// }
-		/// int parentHashCode = INITIAL_HASH;
-		/// for (int i = 0; i &lt; size(); i++) {
-		/// parentHashCode = parentHashCode * HASH_MULTIPLIER ^ getParent(i).hashCode();
-		/// }
-		/// int hashCode = INITIAL_HASH;
-		/// hashCode = hashCode * HASH_MULTIPLIER ^ parentHashCode;
-		/// hashCode = hashCode * HASH_MULTIPLIER ^ returnStateHashCode;
-		/// return hashCode;
-		/// }
-		/// </pre>
-		/// </remarks>
-		private readonly int cachedHashCode;
+        /// <summary>Stores the computed hash code of this PredictionContext.</summary>
+        /// <remarks>
+        /// Stores the computed hash code of this PredictionContext. The hash code is
+        /// computed in parts to match the following reference algorithm.
+        /// <pre>
+        /// private int referenceHashCode() {
+        /// int returnStateHashCode =
+        /// <see cref="InitialHash">INITIAL_HASH</see>
+        /// ;
+        /// for (int i = 0; i &lt; size(); i++) {
+        /// returnStateHashCode = returnStateHashCode *
+        /// <see cref="HashMultiplier">HASH_MULTIPLIER</see>
+        /// ^ getReturnState(i);
+        /// }
+        /// int parentHashCode = INITIAL_HASH;
+        /// for (int i = 0; i &lt; size(); i++) {
+        /// parentHashCode = parentHashCode * HASH_MULTIPLIER ^ getParent(i).hashCode();
+        /// }
+        /// int hashCode = INITIAL_HASH;
+        /// hashCode = hashCode * HASH_MULTIPLIER ^ parentHashCode;
+        /// hashCode = hashCode * HASH_MULTIPLIER ^ returnStateHashCode;
+        /// return hashCode;
+        /// }
+        /// </pre>
+        /// </remarks>
+        private readonly int cachedHashCode;
 
-		protected internal PredictionContext(int cachedHashCode)
-		{
-			this.cachedHashCode = cachedHashCode;
-		}
+        protected internal PredictionContext(int cachedHashCode)
+        {
+            this.cachedHashCode = cachedHashCode;
+        }
 
-		protected internal static int CalculateEmptyParentHashCode()
-		{
-			return InitialHash;
-		}
+        protected internal static int CalculateEmptyParentHashCode()
+        {
+            return InitialHash;
+        }
 
-		protected internal static int CalculateParentHashCode(Antlr4.Runtime.Atn.PredictionContext
-			 parent)
-		{
-			return InitialHash * HashMultiplier ^ parent.GetHashCode();
-		}
+        protected internal static int CalculateParentHashCode(Antlr4.Runtime.Atn.PredictionContext
+             parent)
+        {
+            return InitialHash * HashMultiplier ^ parent.GetHashCode();
+        }
 
-		protected internal static int CalculateParentHashCode(Antlr4.Runtime.Atn.PredictionContext
-			[] parents)
-		{
-			int hashCode = InitialHash;
-			foreach (Antlr4.Runtime.Atn.PredictionContext context in parents)
-			{
-				hashCode = hashCode * HashMultiplier ^ context.GetHashCode();
-			}
-			return hashCode;
-		}
+        protected internal static int CalculateParentHashCode(Antlr4.Runtime.Atn.PredictionContext
+            [] parents)
+        {
+            int hashCode = InitialHash;
+            foreach (Antlr4.Runtime.Atn.PredictionContext context in parents)
+            {
+                hashCode = hashCode * HashMultiplier ^ context.GetHashCode();
+            }
+            return hashCode;
+        }
 
-		protected internal static int CalculateEmptyReturnStateHashCode()
-		{
-			return InitialHash;
-		}
+        protected internal static int CalculateEmptyReturnStateHashCode()
+        {
+            return InitialHash;
+        }
 
-		protected internal static int CalculateReturnStateHashCode(int returnState)
-		{
-			return InitialHash * HashMultiplier ^ returnState;
-		}
+        protected internal static int CalculateReturnStateHashCode(int returnState)
+        {
+            return InitialHash * HashMultiplier ^ returnState;
+        }
 
-		protected internal static int CalculateReturnStatesHashCode(int[] returnStates)
-		{
-			int hashCode = InitialHash;
-			foreach (int state in returnStates)
-			{
-				hashCode = hashCode * HashMultiplier ^ state;
-			}
-			return hashCode;
-		}
+        protected internal static int CalculateReturnStatesHashCode(int[] returnStates)
+        {
+            int hashCode = InitialHash;
+            foreach (int state in returnStates)
+            {
+                hashCode = hashCode * HashMultiplier ^ state;
+            }
+            return hashCode;
+        }
 
-		protected internal static int CalculateHashCode(int parentHashCode, int returnStateHashCode
-			)
-		{
-			return (InitialHash * HashMultiplier ^ parentHashCode) * HashMultiplier ^ returnStateHashCode;
-		}
+        protected internal static int CalculateHashCode(int parentHashCode, int returnStateHashCode
+            )
+        {
+            return (InitialHash * HashMultiplier ^ parentHashCode) * HashMultiplier ^ returnStateHashCode;
+        }
 
-		public abstract int Size
-		{
-			get;
-		}
+        public abstract int Size
+        {
+            get;
+        }
 
-		public abstract int GetReturnState(int index);
+        public abstract int GetReturnState(int index);
 
-		public abstract int FindReturnState(int returnState);
+        public abstract int FindReturnState(int returnState);
 
-		[NotNull]
-		public abstract Antlr4.Runtime.Atn.PredictionContext GetParent(int index);
+        [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 AddEmptyContext(
+            );
 
-		protected internal abstract Antlr4.Runtime.Atn.PredictionContext RemoveEmptyContext
-			();
+        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)
+        {
+            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);
-		}
+        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 AddEmptyContext(Antlr4.Runtime.Atn.PredictionContext
+             context)
+        {
+            return context.AddEmptyContext();
+        }
 
-		private static Antlr4.Runtime.Atn.PredictionContext RemoveEmptyContext(Antlr4.Runtime.Atn.PredictionContext
-			 context)
-		{
-			return context.RemoveEmptyContext();
-		}
+        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);
-		}
+        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);
-				}
-			}
-		}
+        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 bool IsEmptyLocal(Antlr4.Runtime.Atn.PredictionContext context)
+        {
+            return context == EmptyLocal;
+        }
 
-		public static Antlr4.Runtime.Atn.PredictionContext GetCachedContext(Antlr4.Runtime.Atn.PredictionContext
-			 context, IConcurrentMap<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext
-			> contextCache, PredictionContext.IdentityHashMap visited)
-		{
-			if (context.IsEmpty)
-			{
-				return context;
-			}
-			Antlr4.Runtime.Atn.PredictionContext existing = visited.Get(context);
-			if (existing != null)
-			{
-				return existing;
-			}
-			existing = contextCache.Get(context);
-			if (existing != null)
-			{
-				visited.Put(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.PutIfAbsent(context, context);
-				visited.Put(context, existing != null ? existing : context);
-				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.PutIfAbsent(updated, updated);
-			visited.Put(updated, existing != null ? existing : updated);
-			visited.Put(context, existing != null ? existing : updated);
-			return updated;
-		}
+        public static Antlr4.Runtime.Atn.PredictionContext GetCachedContext(Antlr4.Runtime.Atn.PredictionContext
+             context, IConcurrentMap<Antlr4.Runtime.Atn.PredictionContext, Antlr4.Runtime.Atn.PredictionContext
+            > contextCache, PredictionContext.IdentityHashMap visited)
+        {
+            if (context.IsEmpty)
+            {
+                return context;
+            }
+            Antlr4.Runtime.Atn.PredictionContext existing = visited.Get(context);
+            if (existing != null)
+            {
+                return existing;
+            }
+            existing = contextCache.Get(context);
+            if (existing != null)
+            {
+                visited.Put(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.PutIfAbsent(context, context);
+                visited.Put(context, existing != null ? existing : context);
+                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.PutIfAbsent(updated, updated);
+            visited.Put(updated, existing != null ? existing : updated);
+            visited.Put(context, existing != null ? existing : updated);
+            return updated;
+        }
 
-		public virtual Antlr4.Runtime.Atn.PredictionContext AppendContext(int returnContext
-			, PredictionContextCache contextCache)
-		{
-			return AppendContext(Antlr4.Runtime.Atn.PredictionContext.EmptyFull.GetChild(returnContext
-				), contextCache);
-		}
+        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 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 virtual Antlr4.Runtime.Atn.PredictionContext GetChild(int returnState)
+        {
+            return new SingletonPredictionContext(this, returnState);
+        }
 
-		public abstract bool IsEmpty
-		{
-			get;
-		}
+        public abstract bool IsEmpty
+        {
+            get;
+        }
 
-		public abstract bool HasEmpty
-		{
-			get;
-		}
+        public abstract bool HasEmpty
+        {
+            get;
+        }
 
-		public sealed override int GetHashCode()
-		{
-			return cachedHashCode;
-		}
+        public sealed override int GetHashCode()
+        {
+            return cachedHashCode;
+        }
 
-		public abstract override bool Equals(object o);
+        public abstract override bool Equals(object o);
 
-		//@Override
-		//public String toString() {
-		//	return toString(null, Integer.MAX_VALUE);
-		//}
-		public virtual string[] ToStrings<_T0>(Recognizer<_T0> recognizer, int currentState
-			)
-		{
-			return ToStrings(recognizer, Antlr4.Runtime.Atn.PredictionContext.EmptyFull, currentState
-				);
-		}
+        //@Override
+        //public String toString() {
+        //	return toString(null, Integer.MAX_VALUE);
+        //}
+        public virtual string[] ToStrings<_T0>(Recognizer<_T0> recognizer, int currentState
+            )
+        {
+            return ToStrings(recognizer, Antlr4.Runtime.Atn.PredictionContext.EmptyFull, currentState
+                );
+        }
 
-		public virtual string[] ToStrings<_T0>(Recognizer<_T0> recognizer, Antlr4.Runtime.Atn.PredictionContext
-			 stop, int currentState)
-		{
-			IList<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.GetATN();
-						ATNState s = atn.states[stateNumber];
-						string ruleName = recognizer.GetRuleNames()[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.AddItem(localBuffer.ToString());
-				if (last)
-				{
-					break;
-				}
+        public virtual string[] ToStrings<_T0>(Recognizer<_T0> recognizer, Antlr4.Runtime.Atn.PredictionContext
+             stop, int currentState)
+        {
+            IList<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.GetATN();
+                        ATNState s = atn.states[stateNumber];
+                        string ruleName = recognizer.GetRuleNames()[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.AddItem(localBuffer.ToString());
+                if (last)
+                {
+                    break;
+                }
 outer_continue: ;
-			}
+            }
 outer_break: ;
-			return Sharpen.Collections.ToArray(result, new string[result.Count]);
-		}
+            return Sharpen.Collections.ToArray(result, new string[result.Count]);
+        }
 
-		public sealed class IdentityHashMap : FlexibleHashMap<PredictionContext, PredictionContext
-			>
-		{
-			public IdentityHashMap() : base(PredictionContext.IdentityEqualityComparator.Instance
-				)
-			{
-			}
-		}
+        public sealed class IdentityHashMap : FlexibleHashMap<PredictionContext, PredictionContext
+            >
+        {
+            public IdentityHashMap() : base(PredictionContext.IdentityEqualityComparator.Instance
+                )
+            {
+            }
+        }
 
-		public sealed class IdentityEqualityComparator : AbstractEqualityComparator<PredictionContext
-			>
-		{
-			public static readonly PredictionContext.IdentityEqualityComparator Instance = new 
-				PredictionContext.IdentityEqualityComparator();
+        public sealed class IdentityEqualityComparator : AbstractEqualityComparator<PredictionContext
+            >
+        {
+            public static readonly PredictionContext.IdentityEqualityComparator Instance = new 
+                PredictionContext.IdentityEqualityComparator();
 
-			public IdentityEqualityComparator()
-			{
-			}
+            public IdentityEqualityComparator()
+            {
+            }
 
-			public override int HashCode(PredictionContext obj)
-			{
-				return obj.GetHashCode();
-			}
+            public override int HashCode(PredictionContext obj)
+            {
+                return obj.GetHashCode();
+            }
 
-			public override bool Equals(PredictionContext a, PredictionContext b)
-			{
-				return a == b;
-			}
-		}
-	}
+            public override bool Equals(PredictionContext a, PredictionContext b)
+            {
+                return a == b;
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/PredictionContextCache.cs b/Antlr4.Runtime/Atn/PredictionContextCache.cs
index 431a6491d..bfc1f1af5 100644
--- a/Antlr4.Runtime/Atn/PredictionContextCache.cs
+++ b/Antlr4.Runtime/Atn/PredictionContextCache.cs
@@ -33,186 +33,186 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <summary>
-	/// Used to cache
-	/// <see cref="PredictionContext">PredictionContext</see>
-	/// 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);
+    /// <summary>
+    /// Used to cache
+    /// <see cref="PredictionContext">PredictionContext</see>
+    /// 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<PredictionContext, PredictionContext> contexts = new 
+            Dictionary<PredictionContext, PredictionContext>();
 
-		private readonly IDictionary<PredictionContextCache.PredictionContextAndInt, PredictionContext
-			> childContexts = new Dictionary<PredictionContextCache.PredictionContextAndInt, 
-			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 IDictionary<PredictionContextCache.IdentityCommutativePredictionContextOperands
+            , PredictionContext> joinContexts = new Dictionary<PredictionContextCache.IdentityCommutativePredictionContextOperands
+            , PredictionContext>();
 
-		private readonly bool enableCache;
+        private readonly bool enableCache;
 
-		public PredictionContextCache() : this(true)
-		{
-		}
+        public PredictionContextCache() : this(true)
+        {
+        }
 
-		private PredictionContextCache(bool enableCache)
-		{
-			this.enableCache = enableCache;
-		}
+        private PredictionContextCache(bool enableCache)
+        {
+            this.enableCache = enableCache;
+        }
 
-		public virtual PredictionContext GetAsCached(PredictionContext context)
-		{
-			if (!enableCache)
-			{
-				return context;
-			}
-			PredictionContext result = contexts.Get(context);
-			if (result == null)
-			{
-				result = context;
-				contexts.Put(context, context);
-			}
-			return result;
-		}
+        public virtual PredictionContext GetAsCached(PredictionContext context)
+        {
+            if (!enableCache)
+            {
+                return context;
+            }
+            PredictionContext result = contexts.Get(context);
+            if (result == null)
+            {
+                result = context;
+                contexts.Put(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 = childContexts.Get(operands);
-			if (result == null)
-			{
-				result = context.GetChild(invokingState);
-				result = GetAsCached(result);
-				childContexts.Put(operands, result);
-			}
-			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 = childContexts.Get(operands);
+            if (result == null)
+            {
+                result = context.GetChild(invokingState);
+                result = GetAsCached(result);
+                childContexts.Put(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 = joinContexts.Get(operands);
-			if (result != null)
-			{
-				return result;
-			}
-			result = PredictionContext.Join(x, y, this);
-			result = GetAsCached(result);
-			joinContexts.Put(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 = joinContexts.Get(operands);
+            if (result != null)
+            {
+                return result;
+            }
+            result = PredictionContext.Join(x, y, this);
+            result = GetAsCached(result);
+            joinContexts.Put(operands, result);
+            return result;
+        }
 
-		protected internal sealed class PredictionContextAndInt
-		{
-			private readonly PredictionContext obj;
+        protected internal sealed class PredictionContextAndInt
+        {
+            private readonly PredictionContext obj;
 
-			private readonly int value;
+            private readonly int value;
 
-			public PredictionContextAndInt(PredictionContext obj, int value)
-			{
-				this.obj = obj;
-				this.value = 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 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;
-			}
-		}
+            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;
+        protected internal sealed class IdentityCommutativePredictionContextOperands
+        {
+            private readonly PredictionContext x;
 
-			private readonly PredictionContext y;
+            private readonly PredictionContext y;
 
-			public IdentityCommutativePredictionContextOperands(PredictionContext x, PredictionContext
-				 y)
-			{
-				this.x = x;
-				this.y = y;
-			}
+            public IdentityCommutativePredictionContextOperands(PredictionContext x, PredictionContext
+                 y)
+            {
+                this.x = x;
+                this.y = y;
+            }
 
-			public PredictionContext X
-			{
-				get
-				{
-					return x;
-				}
-			}
+            public PredictionContext X
+            {
+                get
+                {
+                    return x;
+                }
+            }
 
-			public PredictionContext Y
-			{
-				get
-				{
-					return y;
-				}
-			}
+            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 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();
-			}
-		}
-	}
+            public override int GetHashCode()
+            {
+                return x.GetHashCode() ^ y.GetHashCode();
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/RangeTransition.cs b/Antlr4.Runtime/Atn/RangeTransition.cs
index 6f22f5d28..b82d49230 100644
--- a/Antlr4.Runtime/Atn/RangeTransition.cs
+++ b/Antlr4.Runtime/Atn/RangeTransition.cs
@@ -33,43 +33,43 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class RangeTransition : Transition
-	{
-		public readonly int from;
+    public sealed class RangeTransition : Transition
+    {
+        public readonly int from;
 
-		public readonly int to;
+        public readonly int to;
 
-		public RangeTransition(ATNState target, int from, int to) : base(target)
-		{
-			this.from = from;
-			this.to = to;
-		}
+        public RangeTransition(ATNState target, int from, int to) : base(target)
+        {
+            this.from = from;
+            this.to = to;
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return Range;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Range;
+            }
+        }
 
-		public override IntervalSet Label
-		{
-			get
-			{
-				return IntervalSet.Of(from, to);
-			}
-		}
+        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;
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return symbol >= from && symbol <= to;
+        }
 
-		[NotNull]
-		public override string ToString()
-		{
-			return "'" + (char)from + "'..'" + (char)to + "'";
-		}
-	}
+        [NotNull]
+        public override string ToString()
+        {
+            return "'" + (char)from + "'..'" + (char)to + "'";
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/RuleStartState.cs b/Antlr4.Runtime/Atn/RuleStartState.cs
index dfce3af19..cf30c3928 100644
--- a/Antlr4.Runtime/Atn/RuleStartState.cs
+++ b/Antlr4.Runtime/Atn/RuleStartState.cs
@@ -32,17 +32,17 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class RuleStartState : ATNState
-	{
-		public RuleStopState stopState;
+    public sealed class RuleStartState : ATNState
+    {
+        public RuleStopState stopState;
 
-		public bool isPrecedenceRule;
+        public bool isPrecedenceRule;
 
-		public bool leftFactored;
+        public bool leftFactored;
 
-		public override int GetStateType()
-		{
-			return RuleStart;
-		}
-	}
+        public override int GetStateType()
+        {
+            return RuleStart;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/RuleStopState.cs b/Antlr4.Runtime/Atn/RuleStopState.cs
index e9dae9234..2af73e073 100644
--- a/Antlr4.Runtime/Atn/RuleStopState.cs
+++ b/Antlr4.Runtime/Atn/RuleStopState.cs
@@ -32,24 +32,24 @@ using 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 GetNonStopStateNumber()
-		{
-			return -1;
-		}
+    /// <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 GetNonStopStateNumber()
+        {
+            return -1;
+        }
 
-		public override int GetStateType()
-		{
-			return RuleStop;
-		}
-	}
+        public override int GetStateType()
+        {
+            return RuleStop;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/RuleTransition.cs b/Antlr4.Runtime/Atn/RuleTransition.cs
index 66be47b37..5bbc432f2 100644
--- a/Antlr4.Runtime/Atn/RuleTransition.cs
+++ b/Antlr4.Runtime/Atn/RuleTransition.cs
@@ -33,49 +33,49 @@ using 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 sealed class RuleTransition : Transition
+    {
+        /// <summary>Ptr to the rule definition object for this rule ref</summary>
+        public readonly int ruleIndex;
 
-		public readonly int precedence;
+        public readonly int precedence;
 
-		/// <summary>What node to begin computations following ref to rule</summary>
-		[NotNull]
-		public ATNState followState;
+        /// <summary>What node to begin computations following ref to rule</summary>
+        [NotNull]
+        public ATNState followState;
 
-		public bool tailCall;
+        public bool tailCall;
 
-		public bool optimizedTailCall;
+        public bool optimizedTailCall;
 
-		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 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 int SerializationType
-		{
-			get
-			{
-				return Rule;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Rule;
+            }
+        }
 
-		public override bool IsEpsilon
-		{
-			get
-			{
-				return true;
-			}
-		}
+        public override bool IsEpsilon
+        {
+            get
+            {
+                return true;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return false;
-		}
-	}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return false;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/SemanticContext.cs b/Antlr4.Runtime/Atn/SemanticContext.cs
index 69e25e36d..1db82d145 100644
--- a/Antlr4.Runtime/Atn/SemanticContext.cs
+++ b/Antlr4.Runtime/Atn/SemanticContext.cs
@@ -35,384 +35,384 @@ using 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
-	/// <code>p1&&p2</code>
-	/// , or a sum of products
-	/// <code>p1||p2</code>
-	/// .
-	/// <p/>
-	/// I have scoped the
-	/// <see cref="AND">AND</see>
-	/// ,
-	/// <see cref="OR">OR</see>
-	/// , and
-	/// <see cref="Predicate">Predicate</see>
-	/// subclasses of
-	/// <see cref="SemanticContext">SemanticContext</see>
-	/// within the scope of this outer class.
-	/// </remarks>
-	public abstract class SemanticContext
-	{
-		public static readonly SemanticContext None = new SemanticContext.Predicate();
+    /// <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
+    /// <code>p1&&p2</code>
+    /// , or a sum of products
+    /// <code>p1||p2</code>
+    /// .
+    /// <p/>
+    /// I have scoped the
+    /// <see cref="AND">AND</see>
+    /// ,
+    /// <see cref="OR">OR</see>
+    /// , and
+    /// <see cref="Predicate">Predicate</see>
+    /// subclasses of
+    /// <see cref="SemanticContext">SemanticContext</see>
+    /// within the scope of this outer class.
+    /// </remarks>
+    public abstract class SemanticContext
+    {
+        public static readonly SemanticContext None = new SemanticContext.Predicate();
 
-		public SemanticContext parent;
+        public SemanticContext parent;
 
-		/// <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.
-		/// </remarks>
-		public abstract bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext);
+        /// <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.
+        /// </remarks>
+        public abstract bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext);
 
-		public class Predicate : SemanticContext
-		{
-			public readonly int ruleIndex;
+        public class Predicate : SemanticContext
+        {
+            public readonly int ruleIndex;
 
-			public readonly int predIndex;
+            public readonly int predIndex;
 
-			public readonly bool isCtxDependent;
+            public readonly bool isCtxDependent;
 
-			public Predicate()
-			{
-				// e.g., $i ref in pred
-				this.ruleIndex = -1;
-				this.predIndex = -1;
-				this.isCtxDependent = false;
-			}
+            public 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 Predicate(int ruleIndex, int predIndex, bool isCtxDependent)
+            {
+                this.ruleIndex = ruleIndex;
+                this.predIndex = predIndex;
+                this.isCtxDependent = isCtxDependent;
+            }
 
-			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
-			{
-				RuleContext localctx = isCtxDependent ? outerContext : null;
-				return parser.Sempred(localctx, ruleIndex, predIndex);
-			}
+            public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+            {
+                RuleContext localctx = isCtxDependent ? outerContext : null;
+                return parser.Sempred(localctx, ruleIndex, predIndex);
+            }
 
-			public override int GetHashCode()
-			{
-				int hashCode = 1;
-				hashCode = 31 * hashCode + ruleIndex;
-				hashCode = 31 * hashCode + predIndex;
-				hashCode = 31 * hashCode + (isCtxDependent ? 1 : 0);
-				return hashCode;
-			}
+            public override int GetHashCode()
+            {
+                int hashCode = 1;
+                hashCode = 31 * hashCode + ruleIndex;
+                hashCode = 31 * hashCode + predIndex;
+                hashCode = 31 * hashCode + (isCtxDependent ? 1 : 0);
+                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 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 override string ToString()
+            {
+                return "{" + ruleIndex + ":" + predIndex + "}?";
+            }
+        }
 
-		public class PrecedencePredicate : SemanticContext, IComparable<SemanticContext.PrecedencePredicate
-			>
-		{
-			public readonly int precedence;
+        public class PrecedencePredicate : SemanticContext, IComparable<SemanticContext.PrecedencePredicate
+            >
+        {
+            public readonly int precedence;
 
-			public PrecedencePredicate()
-			{
-				this.precedence = 0;
-			}
+            public PrecedencePredicate()
+            {
+                this.precedence = 0;
+            }
 
-			public PrecedencePredicate(int precedence)
-			{
-				this.precedence = precedence;
-			}
+            public PrecedencePredicate(int precedence)
+            {
+                this.precedence = precedence;
+            }
 
-			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
-			{
-				return parser.Precpred(outerContext, precedence);
-			}
+            public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+            {
+                return parser.Precpred(outerContext, precedence);
+            }
 
-			public virtual int CompareTo(SemanticContext.PrecedencePredicate o)
-			{
-				return precedence - o.precedence;
-			}
+            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 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 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()
-			{
-				return base.ToString();
-			}
-		}
+            public override string ToString()
+            {
+                return base.ToString();
+            }
+        }
 
-		public class AND : SemanticContext
-		{
-			[NotNull]
-			public readonly SemanticContext[] opnds;
+        public class AND : SemanticContext
+        {
+            [NotNull]
+            public readonly SemanticContext[] opnds;
 
-			public AND(SemanticContext a, SemanticContext b)
-			{
-				ICollection<SemanticContext> operands = new HashSet<SemanticContext>();
-				if (a is SemanticContext.AND)
-				{
-					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.AND)a).opnds
-						));
-				}
-				else
-				{
-					operands.AddItem(a);
-				}
-				if (b is SemanticContext.AND)
-				{
-					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.AND)b).opnds
-						));
-				}
-				else
-				{
-					operands.AddItem(b);
-				}
-				IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates
-					(operands);
-				if (!precedencePredicates.IsEmpty())
-				{
-					// interested in the transition with the lowest precedence
-					SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Min(precedencePredicates
-						);
-					operands.AddItem(reduced);
-				}
-				opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count]
-					);
-			}
+            public AND(SemanticContext a, SemanticContext b)
+            {
+                ICollection<SemanticContext> operands = new HashSet<SemanticContext>();
+                if (a is SemanticContext.AND)
+                {
+                    Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.AND)a).opnds
+                        ));
+                }
+                else
+                {
+                    operands.AddItem(a);
+                }
+                if (b is SemanticContext.AND)
+                {
+                    Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.AND)b).opnds
+                        ));
+                }
+                else
+                {
+                    operands.AddItem(b);
+                }
+                IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates
+                    (operands);
+                if (!precedencePredicates.IsEmpty())
+                {
+                    // interested in the transition with the lowest precedence
+                    SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Min(precedencePredicates
+                        );
+                    operands.AddItem(reduced);
+                }
+                opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count]
+                    );
+            }
 
-			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 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 Arrays.HashCode(opnds);
-			}
+            public override int GetHashCode()
+            {
+                return Arrays.HashCode(opnds);
+            }
 
-			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
-			{
-				foreach (SemanticContext opnd in opnds)
-				{
-					if (!opnd.Eval(parser, outerContext))
-					{
-						return false;
-					}
-				}
-				return true;
-			}
+            public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+            {
+                foreach (SemanticContext opnd in opnds)
+                {
+                    if (!opnd.Eval(parser, outerContext))
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            }
 
-			public override string ToString()
-			{
-				return Utils.Join(opnds, "&&");
-			}
-		}
+            public override string ToString()
+            {
+                return Utils.Join(opnds, "&&");
+            }
+        }
 
-		public class OR : SemanticContext
-		{
-			[NotNull]
-			public readonly SemanticContext[] opnds;
+        public class OR : SemanticContext
+        {
+            [NotNull]
+            public readonly SemanticContext[] opnds;
 
-			public OR(SemanticContext a, SemanticContext b)
-			{
-				ICollection<SemanticContext> operands = new HashSet<SemanticContext>();
-				if (a is SemanticContext.OR)
-				{
-					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.OR)a).opnds)
-						);
-				}
-				else
-				{
-					operands.AddItem(a);
-				}
-				if (b is SemanticContext.OR)
-				{
-					Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.OR)b).opnds)
-						);
-				}
-				else
-				{
-					operands.AddItem(b);
-				}
-				IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates
-					(operands);
-				if (!precedencePredicates.IsEmpty())
-				{
-					// interested in the transition with the highest precedence
-					SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Max(precedencePredicates
-						);
-					operands.AddItem(reduced);
-				}
-				this.opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count
-					]);
-			}
+            public OR(SemanticContext a, SemanticContext b)
+            {
+                ICollection<SemanticContext> operands = new HashSet<SemanticContext>();
+                if (a is SemanticContext.OR)
+                {
+                    Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.OR)a).opnds)
+                        );
+                }
+                else
+                {
+                    operands.AddItem(a);
+                }
+                if (b is SemanticContext.OR)
+                {
+                    Sharpen.Collections.AddAll(operands, Arrays.AsList(((SemanticContext.OR)b).opnds)
+                        );
+                }
+                else
+                {
+                    operands.AddItem(b);
+                }
+                IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates
+                    (operands);
+                if (!precedencePredicates.IsEmpty())
+                {
+                    // interested in the transition with the highest precedence
+                    SemanticContext.PrecedencePredicate reduced = Sharpen.Collections.Max(precedencePredicates
+                        );
+                    operands.AddItem(reduced);
+                }
+                this.opnds = Sharpen.Collections.ToArray(operands, new SemanticContext[operands.Count
+                    ]);
+            }
 
-			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 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 Arrays.HashCode(opnds) + 1;
-			}
+            public override int GetHashCode()
+            {
+                return Arrays.HashCode(opnds) + 1;
+            }
 
-			// differ from AND slightly
-			public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
-			{
-				foreach (SemanticContext opnd in opnds)
-				{
-					if (opnd.Eval(parser, outerContext))
-					{
-						return true;
-					}
-				}
-				return false;
-			}
+            // differ from AND slightly
+            public override bool Eval<_T0>(Recognizer<_T0> parser, RuleContext outerContext)
+            {
+                foreach (SemanticContext opnd in opnds)
+                {
+                    if (opnd.Eval(parser, outerContext))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
 
-			public override string ToString()
-			{
-				return Utils.Join(opnds, "||");
-			}
-		}
+            public override string ToString()
+            {
+                return Utils.Join(opnds, "||");
+            }
+        }
 
-		public static SemanticContext And(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;
-		}
+        public static SemanticContext And(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(Sharpen.BitSet, ATNConfigSet, int)
-		/// 	">ParserATNSimulator.GetPredsForAmbigAlts(Sharpen.BitSet, ATNConfigSet, int)</seealso>
-		public static SemanticContext Or(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;
-		}
+        /// <seealso cref="ParserATNSimulator.GetPredsForAmbigAlts(Sharpen.BitSet, ATNConfigSet, int)
+        ///     ">ParserATNSimulator.GetPredsForAmbigAlts(Sharpen.BitSet, ATNConfigSet, int)</seealso>
+        public static SemanticContext Or(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
-			<_T0>(ICollection<_T0> collection) where _T0:SemanticContext
-		{
-			List<SemanticContext.PrecedencePredicate> result = null;
-			for (IEnumerator<SemanticContext> iterator = collection.GetEnumerator(); iterator
-				.HasNext(); )
-			{
-				SemanticContext context = iterator.Next();
-				if (context is SemanticContext.PrecedencePredicate)
-				{
-					if (result == null)
-					{
-						result = new List<SemanticContext.PrecedencePredicate>();
-					}
-					result.AddItem((SemanticContext.PrecedencePredicate)context);
-					iterator.Remove();
-				}
-			}
-			if (result == null)
-			{
-				return Sharpen.Collections.EmptyList();
-			}
-			return result;
-		}
-	}
+        private static IList<SemanticContext.PrecedencePredicate> FilterPrecedencePredicates
+            <_T0>(ICollection<_T0> collection) where _T0:SemanticContext
+        {
+            List<SemanticContext.PrecedencePredicate> result = null;
+            for (IEnumerator<SemanticContext> iterator = collection.GetEnumerator(); iterator
+                .HasNext(); )
+            {
+                SemanticContext context = iterator.Next();
+                if (context is SemanticContext.PrecedencePredicate)
+                {
+                    if (result == null)
+                    {
+                        result = new List<SemanticContext.PrecedencePredicate>();
+                    }
+                    result.AddItem((SemanticContext.PrecedencePredicate)context);
+                    iterator.Remove();
+                }
+            }
+            if (result == null)
+            {
+                return Sharpen.Collections.EmptyList();
+            }
+            return result;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/SetTransition.cs b/Antlr4.Runtime/Atn/SetTransition.cs
index b0474b44f..7b893a260 100644
--- a/Antlr4.Runtime/Atn/SetTransition.cs
+++ b/Antlr4.Runtime/Atn/SetTransition.cs
@@ -34,48 +34,48 @@ using 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;
+    /// <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(IToken.InvalidType);
-			}
-			this.set = set;
-		}
+        public SetTransition(ATNState target, IntervalSet set) : base(target)
+        {
+            // TODO (sam): should we really allow null here?
+            if (set == null)
+            {
+                set = IntervalSet.Of(IToken.InvalidType);
+            }
+            this.set = set;
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return Set;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Set;
+            }
+        }
 
-		public override IntervalSet Label
-		{
-			get
-			{
-				return set;
-			}
-		}
+        public override IntervalSet Label
+        {
+            get
+            {
+                return set;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return set.Contains(symbol);
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return set.Contains(symbol);
+        }
 
-		[NotNull]
-		public override string ToString()
-		{
-			return set.ToString();
-		}
-	}
+        [NotNull]
+        public override string ToString()
+        {
+            return set.ToString();
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/SimulatorState.cs b/Antlr4.Runtime/Atn/SimulatorState.cs
index 138f95567..70bbc011b 100644
--- a/Antlr4.Runtime/Atn/SimulatorState.cs
+++ b/Antlr4.Runtime/Atn/SimulatorState.cs
@@ -33,25 +33,25 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	/// <author>Sam Harwell</author>
-	public class SimulatorState
-	{
-		public readonly ParserRuleContext outerContext;
+    /// <author>Sam Harwell</author>
+    public class SimulatorState
+    {
+        public readonly ParserRuleContext outerContext;
 
-		public readonly DFAState s0;
+        public readonly DFAState s0;
 
-		public readonly bool useContext;
+        public readonly bool useContext;
 
-		public readonly ParserRuleContext remainingOuterContext;
+        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;
-		}
-	}
+        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/Antlr4.Runtime/Atn/SingletonPredictionContext.cs b/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
index 6dff57647..e6defcc09 100644
--- a/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
+++ b/Antlr4.Runtime/Atn/SingletonPredictionContext.cs
@@ -33,103 +33,103 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public class SingletonPredictionContext : PredictionContext
-	{
-		[NotNull]
-		public readonly PredictionContext parent;
+    public class SingletonPredictionContext : PredictionContext
+    {
+        [NotNull]
+        public readonly PredictionContext parent;
 
-		public readonly int returnState;
+        public readonly int returnState;
 
-		internal SingletonPredictionContext(PredictionContext parent, int returnState) : 
-			base(CalculateHashCode(CalculateParentHashCode(parent), CalculateReturnStateHashCode
-			(returnState)))
-		{
-			System.Diagnostics.Debug.Assert(returnState != EmptyFullStateKey && returnState !=
-				 EmptyLocalStateKey);
-			this.parent = parent;
-			this.returnState = returnState;
-		}
+        internal SingletonPredictionContext(PredictionContext parent, int returnState) : 
+            base(CalculateHashCode(CalculateParentHashCode(parent), CalculateReturnStateHashCode
+            (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 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 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 FindReturnState(int returnState)
+        {
+            return this.returnState == returnState ? 0 : -1;
+        }
 
-		public override int Size
-		{
-			get
-			{
-				return 1;
-			}
-		}
+        public override int Size
+        {
+            get
+            {
+                return 1;
+            }
+        }
 
-		public override bool IsEmpty
-		{
-			get
-			{
-				return false;
-			}
-		}
+        public override bool IsEmpty
+        {
+            get
+            {
+                return false;
+            }
+        }
 
-		public override bool HasEmpty
-		{
-			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
-				);
-		}
+        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 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;
-		}
+        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);
-		}
-	}
+        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/Antlr4.Runtime/Atn/StarBlockStartState.cs b/Antlr4.Runtime/Atn/StarBlockStartState.cs
index 2f6237257..80c80626a 100644
--- a/Antlr4.Runtime/Atn/StarBlockStartState.cs
+++ b/Antlr4.Runtime/Atn/StarBlockStartState.cs
@@ -32,13 +32,13 @@ using 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 int GetStateType()
-		{
-			return StarBlockStart;
-		}
-	}
+    /// <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 int GetStateType()
+        {
+            return StarBlockStart;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/StarLoopEntryState.cs b/Antlr4.Runtime/Atn/StarLoopEntryState.cs
index dbc7f443b..24c71017c 100644
--- a/Antlr4.Runtime/Atn/StarLoopEntryState.cs
+++ b/Antlr4.Runtime/Atn/StarLoopEntryState.cs
@@ -32,13 +32,13 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class StarLoopEntryState : DecisionState
-	{
-		public StarLoopbackState loopBackState;
+    public sealed class StarLoopEntryState : DecisionState
+    {
+        public StarLoopbackState loopBackState;
 
-		public override int GetStateType()
-		{
-			return StarLoopEntry;
-		}
-	}
+        public override int GetStateType()
+        {
+            return StarLoopEntry;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/StarLoopbackState.cs b/Antlr4.Runtime/Atn/StarLoopbackState.cs
index b116b4a35..9f687e6a8 100644
--- a/Antlr4.Runtime/Atn/StarLoopbackState.cs
+++ b/Antlr4.Runtime/Atn/StarLoopbackState.cs
@@ -32,16 +32,16 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class StarLoopbackState : ATNState
-	{
-		public StarLoopEntryState GetLoopEntryState()
-		{
-			return (StarLoopEntryState)Transition(0).target;
-		}
+    public sealed class StarLoopbackState : ATNState
+    {
+        public StarLoopEntryState GetLoopEntryState()
+        {
+            return (StarLoopEntryState)Transition(0).target;
+        }
 
-		public override int GetStateType()
-		{
-			return StarLoopBack;
-		}
-	}
+        public override int GetStateType()
+        {
+            return StarLoopBack;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/TokensStartState.cs b/Antlr4.Runtime/Atn/TokensStartState.cs
index 5b03ae01b..5f60d7aba 100644
--- a/Antlr4.Runtime/Atn/TokensStartState.cs
+++ b/Antlr4.Runtime/Atn/TokensStartState.cs
@@ -32,12 +32,12 @@ using 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 int GetStateType()
-		{
-			return TokenStart;
-		}
-	}
+    /// <summary>The Tokens rule start state linking to each lexer rule start state</summary>
+    public sealed class TokensStartState : DecisionState
+    {
+        public override int GetStateType()
+        {
+            return TokenStart;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Atn/Transition.cs b/Antlr4.Runtime/Atn/Transition.cs
index 49fefb0dc..d614a1370 100644
--- a/Antlr4.Runtime/Atn/Transition.cs
+++ b/Antlr4.Runtime/Atn/Transition.cs
@@ -35,108 +35,108 @@ using 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/>
-	/// 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.
-	/// </remarks>
-	public abstract class Transition
-	{
-		public const int Epsilon = 1;
+    /// <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/>
+    /// 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.
+    /// </remarks>
+    public abstract class Transition
+    {
+        public const int Epsilon = 1;
 
-		public const int Range = 2;
+        public const int Range = 2;
 
-		public const int Rule = 3;
+        public const int Rule = 3;
 
-		public const int Predicate = 4;
+        public const int Predicate = 4;
 
-		public const int Atom = 5;
+        public const int Atom = 5;
 
-		public const int Action = 6;
+        public const int Action = 6;
 
-		public const int Set = 7;
+        public const int Set = 7;
 
-		public const int NotSet = 8;
+        public const int NotSet = 8;
 
-		public const int Wildcard = 9;
+        public const int Wildcard = 9;
 
-		public const int Precedence = 10;
+        public const int Precedence = 10;
 
-		public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList
-			(Arrays.AsList("INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION"
-			, "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"));
+        public static readonly IList<string> serializationNames = Sharpen.Collections.UnmodifiableList
+            (Arrays.AsList("INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION"
+            , "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"));
 
-		private sealed class _Dictionary_86 : Dictionary<Type, int>
-		{
-			public _Dictionary_86()
-			{
-				{
-					// constants for serialization
-					// e.g., {isType(input.LT(1))}?
-					// ~(A|B) or ~atom, wildcard, which convert to next 2
-					this.Put(typeof(EpsilonTransition), Antlr4.Runtime.Atn.Transition.Epsilon);
-					this.Put(typeof(RangeTransition), Antlr4.Runtime.Atn.Transition.Range);
-					this.Put(typeof(RuleTransition), Antlr4.Runtime.Atn.Transition.Rule);
-					this.Put(typeof(PredicateTransition), Antlr4.Runtime.Atn.Transition.Predicate);
-					this.Put(typeof(AtomTransition), Antlr4.Runtime.Atn.Transition.Atom);
-					this.Put(typeof(ActionTransition), Antlr4.Runtime.Atn.Transition.Action);
-					this.Put(typeof(SetTransition), Antlr4.Runtime.Atn.Transition.Set);
-					this.Put(typeof(NotSetTransition), Antlr4.Runtime.Atn.Transition.NotSet);
-					this.Put(typeof(WildcardTransition), Antlr4.Runtime.Atn.Transition.Wildcard);
-					this.Put(typeof(PrecedencePredicateTransition), Antlr4.Runtime.Atn.Transition.Precedence
-						);
-				}
-			}
-		}
+        private sealed class _Dictionary_86 : Dictionary<Type, int>
+        {
+            public _Dictionary_86()
+            {
+                {
+                    // constants for serialization
+                    // e.g., {isType(input.LT(1))}?
+                    // ~(A|B) or ~atom, wildcard, which convert to next 2
+                    this.Put(typeof(EpsilonTransition), Antlr4.Runtime.Atn.Transition.Epsilon);
+                    this.Put(typeof(RangeTransition), Antlr4.Runtime.Atn.Transition.Range);
+                    this.Put(typeof(RuleTransition), Antlr4.Runtime.Atn.Transition.Rule);
+                    this.Put(typeof(PredicateTransition), Antlr4.Runtime.Atn.Transition.Predicate);
+                    this.Put(typeof(AtomTransition), Antlr4.Runtime.Atn.Transition.Atom);
+                    this.Put(typeof(ActionTransition), Antlr4.Runtime.Atn.Transition.Action);
+                    this.Put(typeof(SetTransition), Antlr4.Runtime.Atn.Transition.Set);
+                    this.Put(typeof(NotSetTransition), Antlr4.Runtime.Atn.Transition.NotSet);
+                    this.Put(typeof(WildcardTransition), Antlr4.Runtime.Atn.Transition.Wildcard);
+                    this.Put(typeof(PrecedencePredicateTransition), Antlr4.Runtime.Atn.Transition.Precedence
+                        );
+                }
+            }
+        }
 
-		public static readonly IDictionary<Type, int> serializationTypes = Sharpen.Collections
-			.UnmodifiableMap(new _Dictionary_86());
+        public static readonly IDictionary<Type, int> serializationTypes = Sharpen.Collections
+            .UnmodifiableMap(new _Dictionary_86());
 
-		/// <summary>The target of this transition.</summary>
-		/// <remarks>The target of this transition.</remarks>
-		[NotNull]
-		public ATNState target;
+        /// <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;
-		}
+        protected internal Transition(ATNState target)
+        {
+            if (target == null)
+            {
+                throw new ArgumentNullException("target cannot be null.");
+            }
+            this.target = target;
+        }
 
-		public abstract int SerializationType
-		{
-			get;
-		}
+        public abstract int SerializationType
+        {
+            get;
+        }
 
-		/// <summary>Are we epsilon, action, sempred?</summary>
-		public virtual bool IsEpsilon
-		{
-			get
-			{
-				return false;
-			}
-		}
+        /// <summary>Are we epsilon, action, sempred?</summary>
+        public virtual bool IsEpsilon
+        {
+            get
+            {
+                return false;
+            }
+        }
 
-		public virtual IntervalSet Label
-		{
-			get
-			{
-				return null;
-			}
-		}
+        public virtual IntervalSet Label
+        {
+            get
+            {
+                return null;
+            }
+        }
 
-		public abstract bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol);
-	}
+        public abstract bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol);
+    }
 }
diff --git a/Antlr4.Runtime/Atn/WildcardTransition.cs b/Antlr4.Runtime/Atn/WildcardTransition.cs
index 8438a9a69..50c7ca1cc 100644
--- a/Antlr4.Runtime/Atn/WildcardTransition.cs
+++ b/Antlr4.Runtime/Atn/WildcardTransition.cs
@@ -33,29 +33,29 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Atn
 {
-	public sealed class WildcardTransition : Transition
-	{
-		protected internal WildcardTransition(ATNState target) : base(target)
-		{
-		}
+    public sealed class WildcardTransition : Transition
+    {
+        protected internal WildcardTransition(ATNState target) : base(target)
+        {
+        }
 
-		public override int SerializationType
-		{
-			get
-			{
-				return Wildcard;
-			}
-		}
+        public override int SerializationType
+        {
+            get
+            {
+                return Wildcard;
+            }
+        }
 
-		public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
-		{
-			return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
-		}
+        public override bool Matches(int symbol, int minVocabSymbol, int maxVocabSymbol)
+        {
+            return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
+        }
 
-		[NotNull]
-		public override string ToString()
-		{
-			return ".";
-		}
-	}
+        [NotNull]
+        public override string ToString()
+        {
+            return ".";
+        }
+    }
 }
diff --git a/Antlr4.Runtime/BailErrorStrategy.cs b/Antlr4.Runtime/BailErrorStrategy.cs
index 1d7cfc7cc..2bab91be4 100644
--- a/Antlr4.Runtime/BailErrorStrategy.cs
+++ b/Antlr4.Runtime/BailErrorStrategy.cs
@@ -32,62 +32,62 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>Bail out of parser at first syntax error.</summary>
-	/// <remarks>
-	/// Bail out of parser at first syntax error. Do this to use it:
-	/// <p/>
-	/// <code>myparser.setErrorHandler(new BailErrorStrategy<Token>());</code>
-	/// </remarks>
-	public class BailErrorStrategy : DefaultErrorStrategy
-	{
-		/// <summary>
-		/// Instead of recovering from exception
-		/// <code>e</code>
-		/// , re-throw it wrapped
-		/// in a
-		/// <see cref="ParseCanceledException">ParseCanceledException</see>
-		/// so it is not caught by the
-		/// rule function catches.  Use
-		/// <see cref="System.Exception.InnerException()">System.Exception.InnerException()</see>
-		/// to get the
-		/// original
-		/// <see cref="RecognitionException">RecognitionException</see>
-		/// .
-		/// </summary>
-		public override void Recover(Parser recognizer, RecognitionException e)
-		{
-			for (ParserRuleContext context = recognizer.GetContext(); context != null; context
-				 = ((ParserRuleContext)context.Parent))
-			{
-				context.exception = e;
-			}
-			throw new ParseCanceledException(e);
-		}
+    /// <summary>Bail out of parser at first syntax error.</summary>
+    /// <remarks>
+    /// Bail out of parser at first syntax error. Do this to use it:
+    /// <p/>
+    /// <code>myparser.setErrorHandler(new BailErrorStrategy<Token>());</code>
+    /// </remarks>
+    public class BailErrorStrategy : DefaultErrorStrategy
+    {
+        /// <summary>
+        /// Instead of recovering from exception
+        /// <code>e</code>
+        /// , re-throw it wrapped
+        /// in a
+        /// <see cref="ParseCanceledException">ParseCanceledException</see>
+        /// so it is not caught by the
+        /// rule function catches.  Use
+        /// <see cref="System.Exception.InnerException()">System.Exception.InnerException()</see>
+        /// to get the
+        /// original
+        /// <see cref="RecognitionException">RecognitionException</see>
+        /// .
+        /// </summary>
+        public override void Recover(Parser recognizer, RecognitionException e)
+        {
+            for (ParserRuleContext context = recognizer.GetContext(); 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"></exception>
-		public override IToken RecoverInline(Parser recognizer)
-		{
-			InputMismatchException e = new InputMismatchException(recognizer);
-			for (ParserRuleContext context = recognizer.GetContext(); 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"></exception>
+        public override IToken RecoverInline(Parser recognizer)
+        {
+            InputMismatchException e = new InputMismatchException(recognizer);
+            for (ParserRuleContext context = recognizer.GetContext(); 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)
-		{
-		}
-	}
+        /// <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/Antlr4.Runtime/BaseErrorListener.cs b/Antlr4.Runtime/BaseErrorListener.cs
index 157291305..37f13b9f4 100644
--- a/Antlr4.Runtime/BaseErrorListener.cs
+++ b/Antlr4.Runtime/BaseErrorListener.cs
@@ -34,28 +34,28 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <author>Sam Harwell</author>
-	public class BaseErrorListener : IParserErrorListener
-	{
-		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
-			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
-			IToken
-		{
-		}
+    /// <author>Sam Harwell</author>
+    public class BaseErrorListener : IParserErrorListener
+    {
+        public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
+            , int line, int charPositionInLine, string msg, RecognitionException e) where 
+            T:IToken
+        {
+        }
 
-		public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
-			 stopIndex, BitSet ambigAlts, ATNConfigSet configs)
-		{
-		}
+        public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
+             stopIndex, BitSet ambigAlts, ATNConfigSet configs)
+        {
+        }
 
-		public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
-			, int stopIndex, SimulatorState initialState)
-		{
-		}
+        public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
+            , int stopIndex, SimulatorState initialState)
+        {
+        }
 
-		public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
-			, int stopIndex, SimulatorState acceptState)
-		{
-		}
-	}
+        public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
+            , int stopIndex, SimulatorState acceptState)
+        {
+        }
+    }
 }
diff --git a/Antlr4.Runtime/BufferedTokenStream.cs b/Antlr4.Runtime/BufferedTokenStream.cs
index 0bc96bcbe..14b03d987 100644
--- a/Antlr4.Runtime/BufferedTokenStream.cs
+++ b/Antlr4.Runtime/BufferedTokenStream.cs
@@ -36,638 +36,638 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// Buffer all input tokens but do on-demand fetching of new tokens from
-	/// lexer.
-	/// </summary>
-	/// <remarks>
-	/// 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></code>
-	/// &lt;names:
-	/// hi, <it>}&gt;} has to parse names
-	/// as part of an expression but
-	/// <code>"hi, <it>"</code>
-	/// as a nested template.
-	/// 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.
-	/// (
-	/// <see cref="UnbufferedTokenStream">UnbufferedTokenStream</see>
-	/// is the same way.)  Use
-	/// <see cref="CommonTokenStream">CommonTokenStream</see>
-	/// .
-	/// This is not a subclass of
-	/// <code>UnbufferedTokenStream</code>
-	/// because I don't want
-	/// to confuse small moving window of tokens it uses for the full buffer.
-	/// </remarks>
-	public class BufferedTokenStream : ITokenStream
-	{
-		[NotNull]
-		protected internal ITokenSource tokenSource;
+    /// <summary>
+    /// Buffer all input tokens but do on-demand fetching of new tokens from
+    /// lexer.
+    /// </summary>
+    /// <remarks>
+    /// 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></code>
+    /// &lt;names:
+    /// hi, <it>}&gt;} has to parse names
+    /// as part of an expression but
+    /// <code>"hi, <it>"</code>
+    /// as a nested template.
+    /// 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.
+    /// (
+    /// <see cref="UnbufferedTokenStream">UnbufferedTokenStream</see>
+    /// is the same way.)  Use
+    /// <see cref="CommonTokenStream">CommonTokenStream</see>
+    /// .
+    /// This is not a subclass of
+    /// <code>UnbufferedTokenStream</code>
+    /// because I don't want
+    /// to confuse small moving window of tokens it uses for the full buffer.
+    /// </remarks>
+    public class BufferedTokenStream : ITokenStream
+    {
+        [NotNull]
+        protected internal ITokenSource tokenSource;
 
-		/// <summary>
-		/// Record every single token pulled from the source so we can reproduce
-		/// chunks of it later.
-		/// </summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		protected internal IList<IToken> tokens = new List<IToken>(100);
+        /// <summary>
+        /// Record every single token pulled from the source so we can reproduce
+        /// chunks of it later.
+        /// </summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        protected internal IList<IToken> tokens = new List<IToken>(100);
 
-		/// <summary>
-		/// The index into the tokens list of the current token (next token
-		/// to consume).
-		/// </summary>
-		/// <remarks>
-		/// The index into the tokens list of the current token (next token
-		/// to consume).
-		/// <code>tokens[p]</code>
-		/// should be
-		/// <code>LT(1)</code>
-		/// .
-		/// <code>p==-1</code>
-		/// indicates need
-		/// to initialize with first token.  The ctor doesn't get a token.
-		/// First call to
-		/// <code>LT(1)</code>
-		/// or whatever gets the first token and sets
-		/// <code>p=0;</code>
-		/// .
-		/// </remarks>
-		protected internal int p = -1;
+        /// <summary>
+        /// The index into the tokens list of the current token (next token
+        /// to consume).
+        /// </summary>
+        /// <remarks>
+        /// The index into the tokens list of the current token (next token
+        /// to consume).
+        /// <code>tokens[p]</code>
+        /// should be
+        /// <code>LT(1)</code>
+        /// .
+        /// <code>p==-1</code>
+        /// indicates need
+        /// to initialize with first token.  The ctor doesn't get a token.
+        /// First call to
+        /// <code>LT(1)</code>
+        /// or whatever gets the first token and sets
+        /// <code>p=0;</code>
+        /// .
+        /// </remarks>
+        protected internal int p = -1;
 
-		/// <summary>
-		/// Set to
-		/// <code>true</code>
-		/// when the EOF token is fetched. Do not continue fetching
-		/// tokens after that point, or multiple EOF tokens could end up in the
-		/// <see cref="tokens">tokens</see>
-		/// array.
-		/// </summary>
-		/// <seealso cref="Fetch(int)">Fetch(int)</seealso>
-		protected internal bool fetchedEOF;
+        /// <summary>
+        /// Set to
+        /// <code>true</code>
+        /// when the EOF token is fetched. Do not continue fetching
+        /// tokens after that point, or multiple EOF tokens could end up in the
+        /// <see cref="tokens">tokens</see>
+        /// array.
+        /// </summary>
+        /// <seealso cref="Fetch(int)">Fetch(int)</seealso>
+        protected internal bool fetchedEOF;
 
-		public BufferedTokenStream(ITokenSource tokenSource)
-		{
-			if (tokenSource == null)
-			{
-				throw new ArgumentNullException("tokenSource cannot be null");
-			}
-			this.tokenSource = tokenSource;
-		}
+        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 ITokenSource TokenSource
+        {
+            get
+            {
+                return tokenSource;
+            }
+        }
 
-		public virtual int Index
-		{
-			get
-			{
-				return p;
-			}
-		}
+        public virtual int Index
+        {
+            get
+            {
+                return p;
+            }
+        }
 
-		//	public int range() { return range; }
-		public virtual int Mark()
-		{
-			return 0;
-		}
+        //	public int range() { return range; }
+        public virtual int Mark()
+        {
+            return 0;
+        }
 
-		public virtual void Release(int marker)
-		{
-		}
+        public virtual void Release(int marker)
+        {
+        }
 
-		// no resources to release
-		public virtual void Reset()
-		{
-			Seek(0);
-		}
+        // no resources to release
+        public virtual void Reset()
+        {
+            Seek(0);
+        }
 
-		public virtual void Seek(int index)
-		{
-			LazyInit();
-			p = AdjustSeekIndex(index);
-		}
+        public virtual void Seek(int index)
+        {
+            LazyInit();
+            p = AdjustSeekIndex(index);
+        }
 
-		public virtual int Size
-		{
-			get
-			{
-				return tokens.Count;
-			}
-		}
+        public virtual int Size
+        {
+            get
+            {
+                return tokens.Count;
+            }
+        }
 
-		public virtual void Consume()
-		{
-			if (La(1) == Eof)
-			{
-				throw new InvalidOperationException("cannot consume EOF");
-			}
-			if (Sync(p + 1))
-			{
-				p = AdjustSeekIndex(p + 1);
-			}
-		}
+        public virtual void Consume()
+        {
+            if (La(1) == Eof)
+            {
+                throw new InvalidOperationException("cannot consume EOF");
+            }
+            if (Sync(p + 1))
+            {
+                p = AdjustSeekIndex(p + 1);
+            }
+        }
 
-		/// <summary>
-		/// Make sure index
-		/// <code>i</code>
-		/// in tokens has a token.
-		/// </summary>
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// if a token is located at index
-		/// <code>i</code>
-		/// , otherwise
-		/// <code>false</code>
-		/// .
-		/// </returns>
-		/// <seealso cref="Get(int)">Get(int)</seealso>
-		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>
+        /// Make sure index
+        /// <code>i</code>
+        /// in tokens has a token.
+        /// </summary>
+        /// <returns>
+        /// 
+        /// <code>true</code>
+        /// if a token is located at index
+        /// <code>i</code>
+        /// , otherwise
+        /// <code>false</code>
+        /// .
+        /// </returns>
+        /// <seealso cref="Get(int)">Get(int)</seealso>
+        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
-		/// <code>n</code>
-		/// 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.AddItem(t);
-				if (t.Type == IToken.Eof)
-				{
-					fetchedEOF = true;
-					return i + 1;
-				}
-			}
-			return n;
-		}
+        /// <summary>
+        /// Add
+        /// <code>n</code>
+        /// 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.AddItem(t);
+                if (t.Type == IToken.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];
-		}
+        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 == IToken.Eof)
-				{
-					break;
-				}
-				subset.AddItem(t);
-			}
-			return subset;
-		}
+        /// <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 == IToken.Eof)
+                {
+                    break;
+                }
+                subset.AddItem(t);
+            }
+            return subset;
+        }
 
-		public virtual int La(int i)
-		{
-			return Lt(i).Type;
-		}
+        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];
-		}
+        protected internal virtual IToken Lb(int k)
+        {
+            if ((p - k) < 0)
+            {
+                return null;
+            }
+            return tokens[p - k];
+        }
 
-		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];
-		}
+        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
-		/// <code>i</code>
-		/// . If an
-		/// exception is thrown in this method, the current stream index should not be
-		/// changed.
-		/// <p/>
-		/// For example,
-		/// <see cref="CommonTokenStream">CommonTokenStream</see>
-		/// overrides this method to ensure that
-		/// the seek target is always an on-channel token.
-		/// </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;
-		}
+        /// <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
+        /// <code>i</code>
+        /// . If an
+        /// exception is thrown in this method, the current stream index should not be
+        /// changed.
+        /// <p/>
+        /// For example,
+        /// <see cref="CommonTokenStream">CommonTokenStream</see>
+        /// overrides this method to ensure that
+        /// the seek target is always an on-channel token.
+        /// </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 void LazyInit()
+        {
+            if (p == -1)
+            {
+                Setup();
+            }
+        }
 
-		protected internal virtual void Setup()
-		{
-			Sync(0);
-			p = AdjustSeekIndex(0);
-		}
+        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;
-		}
+        /// <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()
+        {
+            return tokens;
+        }
 
-		public virtual IList<IToken> GetTokens(int start, int stop)
-		{
-			return GetTokens(start, stop, null);
-		}
+        public virtual IList<IToken> GetTokens(int start, int stop)
+        {
+            return GetTokens(start, stop, null);
+        }
 
-		/// <summary>
-		/// Given a start and stop index, return a
-		/// <code>List</code>
-		/// of all tokens in
-		/// the token type
-		/// <code>BitSet</code>
-		/// .  Return
-		/// <code>null</code>
-		/// 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.AddItem(t);
-				}
-			}
-			if (filteredTokens.IsEmpty())
-			{
-				filteredTokens = null;
-			}
-			return filteredTokens;
-		}
+        /// <summary>
+        /// Given a start and stop index, return a
+        /// <code>List</code>
+        /// of all tokens in
+        /// the token type
+        /// <code>BitSet</code>
+        /// .  Return
+        /// <code>null</code>
+        /// 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.AddItem(t);
+                }
+            }
+            if (filteredTokens.IsEmpty())
+            {
+                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);
-		}
+        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
-		/// <code>i</code>
-		/// if
-		/// <code>tokens[i]</code>
-		/// is on channel.  Return
-		/// <code>-1</code>
-		/// if there are no tokens
-		/// on channel between
-		/// <code>i</code>
-		/// and EOF.
-		/// </remarks>
-		protected internal virtual int NextTokenOnChannel(int i, int channel)
-		{
-			Sync(i);
-			IToken token = tokens[i];
-			if (i >= Size)
-			{
-				return -1;
-			}
-			while (token.Channel != channel)
-			{
-				if (token.Type == IToken.Eof)
-				{
-					return -1;
-				}
-				i++;
-				Sync(i);
-				token = tokens[i];
-			}
-			return i;
-		}
+        /// <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
+        /// <code>i</code>
+        /// if
+        /// <code>tokens[i]</code>
+        /// is on channel.  Return
+        /// <code>-1</code>
+        /// if there are no tokens
+        /// on channel between
+        /// <code>i</code>
+        /// and EOF.
+        /// </remarks>
+        protected internal virtual int NextTokenOnChannel(int i, int channel)
+        {
+            Sync(i);
+            IToken token = tokens[i];
+            if (i >= Size)
+            {
+                return -1;
+            }
+            while (token.Channel != channel)
+            {
+                if (token.Type == IToken.Eof)
+                {
+                    return -1;
+                }
+                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
-		/// <code>i</code>
-		/// if
-		/// <code>tokens[i]</code>
-		/// is on channel. Return
-		/// <code>-1</code>
-		/// if there are no tokens
-		/// on channel between
-		/// <code>i</code>
-		/// and
-		/// <code>0</code>
-		/// .
-		/// </remarks>
-		protected internal virtual int PreviousTokenOnChannel(int i, int channel)
-		{
-			while (i >= 0 && tokens[i].Channel != channel)
-			{
-				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
+        /// <code>i</code>
+        /// if
+        /// <code>tokens[i]</code>
+        /// is on channel. Return
+        /// <code>-1</code>
+        /// if there are no tokens
+        /// on channel between
+        /// <code>i</code>
+        /// and
+        /// <code>0</code>
+        /// .
+        /// </remarks>
+        protected internal virtual int PreviousTokenOnChannel(int i, int channel)
+        {
+            while (i >= 0 && tokens[i].Channel != channel)
+            {
+                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">Lexer.DefaultTokenChannel</see>
-		/// or
-		/// EOF. If
-		/// <code>channel</code>
-		/// is
-		/// <code>-1</code>
-		/// , 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 tokens on specified channel to the right of
+        /// the current token up until we see a token on
+        /// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
+        /// or
+        /// EOF. If
+        /// <code>channel</code>
+        /// is
+        /// <code>-1</code>
+        /// , 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">Lexer.DefaultTokenChannel</see>
-		/// or EOF.
-		/// </summary>
-		public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex)
-		{
-			return GetHiddenTokensToRight(tokenIndex, -1);
-		}
+        /// <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">Lexer.DefaultTokenChannel</see>
+        /// 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">Lexer.DefaultTokenChannel</see>
-		/// .
-		/// If
-		/// <code>channel</code>
-		/// is
-		/// <code>-1</code>
-		/// , 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));
-			}
-			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 tokens on specified channel to the left of
+        /// the current token up until we see a token on
+        /// <see cref="Lexer.DefaultTokenChannel">Lexer.DefaultTokenChannel</see>
+        /// .
+        /// If
+        /// <code>channel</code>
+        /// is
+        /// <code>-1</code>
+        /// , 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));
+            }
+            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">Lexer.DefaultTokenChannel</see>
-		/// .
-		/// </summary>
-		public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex)
-		{
-			return GetHiddenTokensToLeft(tokenIndex, -1);
-		}
+        /// <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">Lexer.DefaultTokenChannel</see>
+        /// .
+        /// </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.AddItem(t);
-					}
-				}
-				else
-				{
-					if (t.Channel == channel)
-					{
-						hidden.AddItem(t);
-					}
-				}
-			}
-			if (hidden.IsEmpty())
-			{
-				return null;
-			}
-			return hidden;
-		}
+        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.AddItem(t);
+                    }
+                }
+                else
+                {
+                    if (t.Channel == channel)
+                    {
+                        hidden.AddItem(t);
+                    }
+                }
+            }
+            if (hidden.IsEmpty())
+            {
+                return null;
+            }
+            return hidden;
+        }
 
-		public virtual string SourceName
-		{
-			get
-			{
-				return tokenSource.SourceName;
-			}
-		}
+        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>
-		[NotNull]
-		public virtual string GetText()
-		{
-			Fill();
-			return GetText(Interval.Of(0, Size - 1));
-		}
+        /// <summary>Get the text of all tokens in this buffer.</summary>
+        /// <remarks>Get the text of all tokens in this buffer.</remarks>
+        [NotNull]
+        public virtual string GetText()
+        {
+            Fill();
+            return GetText(Interval.Of(0, Size - 1));
+        }
 
-		[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 == IToken.Eof)
-				{
-					break;
-				}
-				buf.Append(t.Text);
-			}
-			return buf.ToString();
-		}
+        [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 == IToken.Eof)
+                {
+                    break;
+                }
+                buf.Append(t.Text);
+            }
+            return buf.ToString();
+        }
 
-		[NotNull]
-		public virtual string GetText(RuleContext ctx)
-		{
-			return GetText(ctx.SourceInterval);
-		}
+        [NotNull]
+        public virtual string GetText(RuleContext ctx)
+        {
+            return GetText(ctx.SourceInterval);
+        }
 
-		[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;
-		}
+        [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;
-				}
-			}
-		}
-	}
+        /// <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/Antlr4.Runtime/CommonToken.cs b/Antlr4.Runtime/CommonToken.cs
index b1802042e..7908bb22c 100644
--- a/Antlr4.Runtime/CommonToken.cs
+++ b/Antlr4.Runtime/CommonToken.cs
@@ -34,252 +34,252 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	[System.Serializable]
-	public class CommonToken : IWritableToken
-	{
-		private const long serialVersionUID = -6708843461296520577L;
+    [System.Serializable]
+    public class CommonToken : IWritableToken
+    {
+        private const long serialVersionUID = -6708843461296520577L;
 
-		protected internal int type;
+        protected internal int type;
 
-		protected internal int line;
+        protected internal int line;
 
-		protected internal int charPositionInLine = -1;
+        protected internal int charPositionInLine = -1;
 
-		protected internal int channel = DefaultChannel;
+        protected internal int channel = DefaultChannel;
 
-		protected internal Tuple<ITokenSource, ICharStream> source;
+        protected internal Tuple<ITokenSource, ICharStream> source;
 
-		/// <summary>We need to be able to change the text once in a while.</summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		protected internal string text;
+        /// <summary>We need to be able to change the text once in a while.</summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        protected internal string text;
 
-		/// <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index
-		/// 	</summary>
-		protected internal int index = -1;
+        /// <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index
+        ///     </summary>
+        protected internal int index = -1;
 
-		/// <summary>The char position into the input buffer where this token starts</summary>
-		protected internal int start;
+        /// <summary>The char position into the input buffer where this token starts</summary>
+        protected internal int start;
 
-		/// <summary>The char position into the input buffer where this token stops</summary>
-		protected internal int stop;
+        /// <summary>The char position into the input buffer where this token stops</summary>
+        protected internal int stop;
 
-		public CommonToken(int type)
-		{
-			// set to invalid position
-			// TODO: can store these in map in token stream rather than as field here
-			this.type = type;
-		}
+        public CommonToken(int type)
+        {
+            // set to invalid position
+            // TODO: can store these in map in token stream rather than as field here
+            this.type = type;
+        }
 
-		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.GetItem1() != null)
-			{
-				this.line = source.GetItem1().Line;
-				this.charPositionInLine = source.GetItem1().Column;
-			}
-		}
+        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.GetItem1() != null)
+            {
+                this.line = source.GetItem1().Line;
+                this.charPositionInLine = source.GetItem1().Column;
+            }
+        }
 
-		public CommonToken(int type, string text)
-		{
-			this.type = type;
-			this.channel = DefaultChannel;
-			this.text = text;
-		}
+        public CommonToken(int type, string text)
+        {
+            this.type = type;
+            this.channel = DefaultChannel;
+            this.text = text;
+        }
 
-		public CommonToken(IToken oldToken)
-		{
-			text = oldToken.Text;
-			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)
-			{
-				source = ((Antlr4.Runtime.CommonToken)oldToken).source;
-			}
-			else
-			{
-				source = Tuple.Create(oldToken.TokenSource, oldToken.InputStream);
-			}
-		}
+        public CommonToken(IToken oldToken)
+        {
+            text = oldToken.Text;
+            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)
+            {
+                source = ((Antlr4.Runtime.CommonToken)oldToken).source;
+            }
+            else
+            {
+                source = Tuple.Create(oldToken.TokenSource, oldToken.InputStream);
+            }
+        }
 
-		public virtual int Type
-		{
-			get
-			{
-				return type;
-			}
-			set
-			{
-				int type = value;
-				this.type = type;
-			}
-		}
+        public virtual int Type
+        {
+            get
+            {
+                return type;
+            }
+            set
+            {
+                int type = value;
+                this.type = type;
+            }
+        }
 
-		public virtual int Line
-		{
-			get
-			{
-				return line;
-			}
-			set
-			{
-				int line = value;
-				this.line = line;
-			}
-		}
+        public virtual int Line
+        {
+            get
+            {
+                return line;
+            }
+            set
+            {
+                int line = value;
+                this.line = line;
+            }
+        }
 
-		/// <summary>Override the text for this token.</summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		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
-			{
-				string text = value;
-				this.text = text;
-			}
-		}
+        /// <summary>Override the text for this token.</summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        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
+            {
+                string text = value;
+                this.text = text;
+            }
+        }
 
-		public virtual int Column
-		{
-			get
-			{
-				return charPositionInLine;
-			}
-			set
-			{
-				int charPositionInLine = value;
-				this.charPositionInLine = charPositionInLine;
-			}
-		}
+        public virtual int Column
+        {
+            get
+            {
+                return charPositionInLine;
+            }
+            set
+            {
+                int charPositionInLine = value;
+                this.charPositionInLine = charPositionInLine;
+            }
+        }
 
-		public virtual int Channel
-		{
-			get
-			{
-				return channel;
-			}
-			set
-			{
-				int channel = value;
-				this.channel = channel;
-			}
-		}
+        public virtual int Channel
+        {
+            get
+            {
+                return channel;
+            }
+            set
+            {
+                int channel = value;
+                this.channel = channel;
+            }
+        }
 
-		public virtual int StartIndex
-		{
-			get
-			{
-				return start;
-			}
-		}
+        public virtual int StartIndex
+        {
+            get
+            {
+                return start;
+            }
+        }
 
-		public virtual void SetStartIndex(int start)
-		{
-			this.start = start;
-		}
+        public virtual void SetStartIndex(int start)
+        {
+            this.start = start;
+        }
 
-		public virtual int StopIndex
-		{
-			get
-			{
-				return stop;
-			}
-		}
+        public virtual int StopIndex
+        {
+            get
+            {
+                return stop;
+            }
+        }
 
-		public virtual void SetStopIndex(int stop)
-		{
-			this.stop = stop;
-		}
+        public virtual void SetStopIndex(int stop)
+        {
+            this.stop = stop;
+        }
 
-		public virtual int TokenIndex
-		{
-			get
-			{
-				return index;
-			}
-			set
-			{
-				int index = value;
-				this.index = index;
-			}
-		}
+        public virtual int TokenIndex
+        {
+            get
+            {
+                return index;
+            }
+            set
+            {
+                int index = value;
+                this.index = index;
+            }
+        }
 
-		public virtual ITokenSource TokenSource
-		{
-			get
-			{
-				return source.GetItem1();
-			}
-		}
+        public virtual ITokenSource TokenSource
+        {
+            get
+            {
+                return source.GetItem1();
+            }
+        }
 
-		public virtual ICharStream InputStream
-		{
-			get
-			{
-				return source.GetItem2();
-			}
-		}
+        public virtual ICharStream InputStream
+        {
+            get
+            {
+                return source.GetItem2();
+            }
+        }
 
-		public override string ToString()
-		{
-			string channelStr = string.Empty;
-			if (channel > 0)
-			{
-				channelStr = ",channel=" + channel;
-			}
-			string txt = Text;
-			if (txt != null)
-			{
-				txt = txt.ReplaceAll("\n", "\\\\n");
-				txt = txt.ReplaceAll("\r", "\\\\r");
-				txt = txt.ReplaceAll("\t", "\\\\t");
-			}
-			else
-			{
-				txt = "<no text>";
-			}
-			return "[@" + TokenIndex + "," + start + ":" + stop + "='" + txt + "',<" + type +
-				 ">" + channelStr + "," + line + ":" + Column + "]";
-		}
-	}
+        public override string ToString()
+        {
+            string channelStr = string.Empty;
+            if (channel > 0)
+            {
+                channelStr = ",channel=" + channel;
+            }
+            string txt = Text;
+            if (txt != null)
+            {
+                txt = txt.ReplaceAll("\n", "\\\\n");
+                txt = txt.ReplaceAll("\r", "\\\\r");
+                txt = txt.ReplaceAll("\t", "\\\\t");
+            }
+            else
+            {
+                txt = "<no text>";
+            }
+            return "[@" + TokenIndex + "," + start + ":" + stop + "='" + txt + "',<" + type +
+                 ">" + channelStr + "," + line + ":" + Column + "]";
+        }
+    }
 }
diff --git a/Antlr4.Runtime/CommonTokenFactory.cs b/Antlr4.Runtime/CommonTokenFactory.cs
index 423c89602..3f343b311 100644
--- a/Antlr4.Runtime/CommonTokenFactory.cs
+++ b/Antlr4.Runtime/CommonTokenFactory.cs
@@ -34,59 +34,60 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public class CommonTokenFactory : ITokenFactory
-	{
-		public static readonly ITokenFactory Default = new Antlr4.Runtime.CommonTokenFactory
-			();
+    public class CommonTokenFactory : ITokenFactory
+    {
+        public static readonly ITokenFactory Default = new Antlr4.Runtime.CommonTokenFactory
+            ();
 
-		/// <summary>Copy text for token out of input char stream.</summary>
-		/// <remarks>
-		/// Copy text for token out of input char stream. Useful when input
-		/// stream is unbuffered.
-		/// </remarks>
-		/// <seealso cref="UnbufferedCharStream">UnbufferedCharStream</seealso>
-		protected internal readonly bool copyText;
+        /// <summary>Copy text for token out of input char stream.</summary>
+        /// <remarks>
+        /// Copy text for token out of input char stream. Useful when input
+        /// stream is unbuffered.
+        /// </remarks>
+        /// <seealso cref="UnbufferedCharStream">UnbufferedCharStream</seealso>
+        protected internal readonly bool copyText;
 
-		/// <summary>
-		/// Create factory and indicate whether or not the factory copy
-		/// text out of the char stream.
-		/// </summary>
-		/// <remarks>
-		/// Create factory and indicate whether or not the factory copy
-		/// text out of the char stream.
-		/// </remarks>
-		public CommonTokenFactory(bool copyText)
-		{
-			this.copyText = copyText;
-		}
+        /// <summary>
+        /// Create factory and indicate whether or not the factory copy
+        /// text out of the char stream.
+        /// </summary>
+        /// <remarks>
+        /// Create factory and indicate whether or not the factory copy
+        /// text out of the char stream.
+        /// </remarks>
+        public CommonTokenFactory(bool copyText)
+        {
+            this.copyText = copyText;
+        }
 
-		public CommonTokenFactory() : this(false)
-		{
-		}
+        public CommonTokenFactory() : this(false)
+        {
+        }
 
-		public virtual CommonToken Create<_T0>(Tuple<_T0> source, int type, string text, 
-			int channel, int start, int stop, int line, int charPositionInLine) where _T0:ITokenSource
-		{
-			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.GetItem2() != null)
-				{
-					t.Text = source.GetItem2().GetText(Interval.Of(start, stop));
-				}
-			}
-			return t;
-		}
+        public virtual CommonToken Create<_T0>(Tuple<_T0> source, int type, string text, 
+            int channel, int start, int stop, int line, int charPositionInLine) where _T0:
+            ITokenSource
+        {
+            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.GetItem2() != null)
+                {
+                    t.Text = source.GetItem2().GetText(Interval.Of(start, stop));
+                }
+            }
+            return t;
+        }
 
-		public virtual CommonToken Create(int type, string text)
-		{
-			return new CommonToken(type, text);
-		}
-	}
+        public virtual CommonToken Create(int type, string text)
+        {
+            return new CommonToken(type, text);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/CommonTokenStream.cs b/Antlr4.Runtime/CommonTokenStream.cs
index bd26f3a9e..5aaa07a21 100644
--- a/Antlr4.Runtime/CommonTokenStream.cs
+++ b/Antlr4.Runtime/CommonTokenStream.cs
@@ -32,125 +32,125 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// 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).
-	/// </summary>
-	/// <remarks>
-	/// 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).
-	/// 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.
-	/// The only difference between this stream and
-	/// <see cref="BufferedTokenStream">BufferedTokenStream</see>
-	/// 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</code>
-	/// instead of calling
-	/// <code>skip()</code>
-	/// in lexer rules.)
-	/// </remarks>
-	/// <seealso cref="UnbufferedTokenStream">UnbufferedTokenStream</seealso>
-	/// <seealso cref="BufferedTokenStream">BufferedTokenStream</seealso>
-	public class CommonTokenStream : BufferedTokenStream
-	{
-		/// <summary>Skip tokens on any channel but this one; this is how we skip whitespace...
-		/// 	</summary>
-		/// <remarks>Skip tokens on any channel but this one; this is how we skip whitespace...
-		/// 	</remarks>
-		protected internal int channel = IToken.DefaultChannel;
+    /// <summary>
+    /// 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).
+    /// </summary>
+    /// <remarks>
+    /// 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).
+    /// 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.
+    /// The only difference between this stream and
+    /// <see cref="BufferedTokenStream">BufferedTokenStream</see>
+    /// 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</code>
+    /// instead of calling
+    /// <code>skip()</code>
+    /// in lexer rules.)
+    /// </remarks>
+    /// <seealso cref="UnbufferedTokenStream">UnbufferedTokenStream</seealso>
+    /// <seealso cref="BufferedTokenStream">BufferedTokenStream</seealso>
+    public class CommonTokenStream : BufferedTokenStream
+    {
+        /// <summary>Skip tokens on any channel but this one; this is how we skip whitespace...
+        ///     </summary>
+        /// <remarks>Skip tokens on any channel but this one; this is how we skip whitespace...
+        ///     </remarks>
+        protected internal int channel = IToken.DefaultChannel;
 
-		public CommonTokenStream(ITokenSource tokenSource) : base(tokenSource)
-		{
-		}
+        public CommonTokenStream(ITokenSource tokenSource) : base(tokenSource)
+        {
+        }
 
-		public CommonTokenStream(ITokenSource tokenSource, int channel) : this(tokenSource
-			)
-		{
-			this.channel = channel;
-		}
+        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 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];
-		}
+        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];
-		}
+        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 == IToken.Eof)
-				{
-					break;
-				}
-			}
-			return n;
-		}
-	}
+        /// <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 == IToken.Eof)
+                {
+                    break;
+                }
+            }
+            return n;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ConsoleErrorListener.cs b/Antlr4.Runtime/ConsoleErrorListener.cs
index ac7bc7841..7c795085b 100644
--- a/Antlr4.Runtime/ConsoleErrorListener.cs
+++ b/Antlr4.Runtime/ConsoleErrorListener.cs
@@ -32,16 +32,16 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <author>Sam Harwell</author>
-	public class ConsoleErrorListener : IAntlrErrorListener<object>
-	{
-		public static readonly ConsoleErrorListener Instance = new ConsoleErrorListener();
+    /// <author>Sam Harwell</author>
+    public class ConsoleErrorListener : IAntlrErrorListener<object>
+    {
+        public static readonly ConsoleErrorListener Instance = new ConsoleErrorListener();
 
-		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
-			, int line, int charPositionInLine, string msg, RecognitionException e)
-		{
-			System.Console.Error.WriteLine("line " + line + ":" + charPositionInLine + " " + 
-				msg);
-		}
-	}
+        public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
+            , int line, int charPositionInLine, string msg, RecognitionException e)
+        {
+            System.Console.Error.WriteLine("line " + line + ":" + charPositionInLine + " " + 
+                msg);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/DefaultErrorStrategy.cs b/Antlr4.Runtime/DefaultErrorStrategy.cs
index a4d51371b..93cc581c0 100644
--- a/Antlr4.Runtime/DefaultErrorStrategy.cs
+++ b/Antlr4.Runtime/DefaultErrorStrategy.cs
@@ -35,515 +35,515 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// This is the default error handling mechanism for ANTLR parsers
-	/// and tree parsers.
-	/// </summary>
-	/// <remarks>
-	/// This is the default error handling mechanism for ANTLR parsers
-	/// and tree parsers.
-	/// </remarks>
-	public class DefaultErrorStrategy : IAntlrErrorStrategy
-	{
-		/// <summary>
-		/// This is true after we see an error and before having successfully
-		/// matched a token.
-		/// </summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		protected internal bool errorRecoveryMode = false;
+    /// <summary>
+    /// This is the default error handling mechanism for ANTLR parsers
+    /// and tree parsers.
+    /// </summary>
+    /// <remarks>
+    /// This is the default error handling mechanism for ANTLR parsers
+    /// and tree parsers.
+    /// </remarks>
+    public class DefaultErrorStrategy : IAntlrErrorStrategy
+    {
+        /// <summary>
+        /// This is true after we see an error and before having successfully
+        /// matched a token.
+        /// </summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        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;
+        /// <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;
+        protected internal IntervalSet lastErrorStates;
 
-		public virtual void BeginErrorCondition(Parser recognizer)
-		{
-			errorRecoveryMode = true;
-		}
+        public virtual void BeginErrorCondition(Parser recognizer)
+        {
+            errorRecoveryMode = true;
+        }
 
-		public virtual bool InErrorRecoveryMode(Parser recognizer)
-		{
-			return errorRecoveryMode;
-		}
+        public virtual bool InErrorRecoveryMode(Parser recognizer)
+        {
+            return errorRecoveryMode;
+        }
 
-		public virtual void EndErrorCondition(Parser recognizer)
-		{
-			errorRecoveryMode = false;
-			lastErrorStates = null;
-			lastErrorIndex = -1;
-		}
+        public virtual void EndErrorCondition(Parser recognizer)
+        {
+            errorRecoveryMode = false;
+            lastErrorStates = null;
+            lastErrorIndex = -1;
+        }
 
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		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 (errorRecoveryMode)
-			{
-				//			System.err.print("[SPURIOUS] ");
-				return;
-			}
-			// don't count spurious errors
-			recognizer._syntaxErrors++;
-			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
-					{
-						System.Console.Error.WriteLine("unknown recognition error type: " + e.GetType().FullName
-							);
-						NotifyErrorListeners(recognizer, e.Message, e);
-					}
-				}
-			}
-		}
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        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 (errorRecoveryMode)
+            {
+                //			System.err.print("[SPURIOUS] ");
+                return;
+            }
+            // don't count spurious errors
+            recognizer._syntaxErrors++;
+            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
+                    {
+                        System.Console.Error.WriteLine("unknown recognition error type: " + e.GetType().FullName
+                            );
+                        NotifyErrorListeners(recognizer, e.Message, e);
+                    }
+                }
+            }
+        }
 
-		protected internal virtual void NotifyErrorListeners(Parser recognizer, string message
-			, RecognitionException e)
-		{
-			if (recognizer != null)
-			{
-				recognizer.NotifyErrorListeners(e.GetOffendingToken(), message, e);
-			}
-		}
+        protected internal virtual void NotifyErrorListeners(Parser recognizer, string message
+            , RecognitionException e)
+        {
+            if (recognizer != null)
+            {
+                recognizer.NotifyErrorListeners(e.GetOffendingToken(), message, e);
+            }
+        }
 
-		/// <summary>Recover from NoViableAlt errors.</summary>
-		/// <remarks>
-		/// Recover from NoViableAlt errors. Also there could be a mismatched
-		/// token that the match() routine could not recover from.
-		/// </remarks>
-		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.GetInputStream()).Index && lastErrorStates
-				 != null && lastErrorStates.Contains(recognizer.GetState()))
-			{
-				// 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.GetInputStream()).Index;
-			if (lastErrorStates == null)
-			{
-				lastErrorStates = new IntervalSet();
-			}
-			lastErrorStates.Add(recognizer.GetState());
-			IntervalSet followSet = GetErrorRecoverySet(recognizer);
-			ConsumeUntil(recognizer, followSet);
-		}
+        /// <summary>Recover from NoViableAlt errors.</summary>
+        /// <remarks>
+        /// Recover from NoViableAlt errors. Also there could be a mismatched
+        /// token that the match() routine could not recover from.
+        /// </remarks>
+        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.GetInputStream()).Index && lastErrorStates
+                 != null && lastErrorStates.Contains(recognizer.GetState()))
+            {
+                // 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.GetInputStream()).Index;
+            if (lastErrorStates == null)
+            {
+                lastErrorStates = new IntervalSet();
+            }
+            lastErrorStates.Add(recognizer.GetState());
+            IntervalSet followSet = GetErrorRecoverySet(recognizer);
+            ConsumeUntil(recognizer, followSet);
+        }
 
-		/// <summary>
-		/// Make sure that the current lookahead symbol is consistent with
-		/// what were expecting at this point in the ATN.
-		/// </summary>
-		/// <remarks>
-		/// Make sure that the current lookahead symbol is consistent with
-		/// what were expecting at this point in the ATN.
-		/// At the start of a sub rule upon error, 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.
-		/// If the sub rule is optional, ()? or ()* or optional alternative,
-		/// then the expected set includes what follows the subrule.
-		/// 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.
-		/// </remarks>
-		public virtual void Sync(Parser recognizer)
-		{
-			ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
-			//		System.err.println("sync @ "+s.stateNumber+"="+s.getClass().getSimpleName());
-			// If already recovering, don't try to sync
-			if (errorRecoveryMode)
-			{
-				return;
-			}
-			ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
-			int la = tokens.La(1);
-			// try cheaper subset first; might get lucky. seems to shave a wee bit off
-			if (recognizer.GetATN().NextTokens(s).Contains(la) || la == IToken.Eof)
-			{
-				return;
-			}
-			// Return but don't end recovery. only do that upon valid token match
-			if (recognizer.IsExpectedToken(la))
-			{
-				return;
-			}
-			switch (s.GetStateType())
-			{
-				case ATNState.BlockStart:
-				case ATNState.StarBlockStart:
-				case ATNState.PlusBlockStart:
-				case ATNState.StarLoopEntry:
-				{
-					// report error and recover if possible
-					if (SingleTokenDeletion(recognizer) != null)
-					{
-						return;
-					}
-					throw new InputMismatchException(recognizer);
-				}
+        /// <summary>
+        /// Make sure that the current lookahead symbol is consistent with
+        /// what were expecting at this point in the ATN.
+        /// </summary>
+        /// <remarks>
+        /// Make sure that the current lookahead symbol is consistent with
+        /// what were expecting at this point in the ATN.
+        /// At the start of a sub rule upon error, 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.
+        /// If the sub rule is optional, ()? or ()* or optional alternative,
+        /// then the expected set includes what follows the subrule.
+        /// 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.
+        /// </remarks>
+        public virtual void Sync(Parser recognizer)
+        {
+            ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
+            //		System.err.println("sync @ "+s.stateNumber+"="+s.getClass().getSimpleName());
+            // If already recovering, don't try to sync
+            if (errorRecoveryMode)
+            {
+                return;
+            }
+            ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
+            int la = tokens.La(1);
+            // try cheaper subset first; might get lucky. seems to shave a wee bit off
+            if (recognizer.GetATN().NextTokens(s).Contains(la) || la == IToken.Eof)
+            {
+                return;
+            }
+            // Return but don't end recovery. only do that upon valid token match
+            if (recognizer.IsExpectedToken(la))
+            {
+                return;
+            }
+            switch (s.GetStateType())
+            {
+                case ATNState.BlockStart:
+                case ATNState.StarBlockStart:
+                case ATNState.PlusBlockStart:
+                case ATNState.StarLoopEntry:
+                {
+                    // report error and recover if possible
+                    if (SingleTokenDeletion(recognizer) != null)
+                    {
+                        return;
+                    }
+                    throw new InputMismatchException(recognizer);
+                }
 
-				case ATNState.PlusLoopBack:
-				case ATNState.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;
-				}
+                case ATNState.PlusLoopBack:
+                case ATNState.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;
-					break;
-				}
-			}
-		}
+                default:
+                {
+                    // do nothing if we can't identify the exact kind of ATN state
+                    break;
+                    break;
+                }
+            }
+        }
 
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual void ReportNoViableAlternative(Parser recognizer, NoViableAltException
-			 e)
-		{
-			ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
-			string input;
-			if (tokens != null)
-			{
-				if (e.GetStartToken().Type == IToken.Eof)
-				{
-					input = "<EOF>";
-				}
-				else
-				{
-					input = tokens.GetText(e.GetStartToken(), e.GetOffendingToken());
-				}
-			}
-			else
-			{
-				input = "<unknown input>";
-			}
-			string msg = "no viable alternative at input " + EscapeWSAndQuote(input);
-			NotifyErrorListeners(recognizer, msg, e);
-		}
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        public virtual void ReportNoViableAlternative(Parser recognizer, NoViableAltException
+             e)
+        {
+            ITokenStream tokens = ((ITokenStream)recognizer.GetInputStream());
+            string input;
+            if (tokens != null)
+            {
+                if (e.GetStartToken().Type == IToken.Eof)
+                {
+                    input = "<EOF>";
+                }
+                else
+                {
+                    input = tokens.GetText(e.GetStartToken(), e.GetOffendingToken());
+                }
+            }
+            else
+            {
+                input = "<unknown input>";
+            }
+            string msg = "no viable alternative at input " + EscapeWSAndQuote(input);
+            NotifyErrorListeners(recognizer, msg, e);
+        }
 
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual void ReportInputMismatch(Parser recognizer, InputMismatchException
-			 e)
-		{
-			string msg = "mismatched input " + GetTokenErrorDisplay(e.GetOffendingToken()) + 
-				" expecting " + e.GetExpectedTokens().ToString(recognizer.GetTokenNames());
-			NotifyErrorListeners(recognizer, msg, e);
-		}
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        public virtual void ReportInputMismatch(Parser recognizer, InputMismatchException
+             e)
+        {
+            string msg = "mismatched input " + GetTokenErrorDisplay(e.GetOffendingToken()) + 
+                " expecting " + e.GetExpectedTokens().ToString(recognizer.GetTokenNames());
+            NotifyErrorListeners(recognizer, msg, e);
+        }
 
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual void ReportFailedPredicate(Parser recognizer, FailedPredicateException
-			 e)
-		{
-			string ruleName = recognizer.GetRuleNames()[recognizer._ctx.GetRuleIndex()];
-			string msg = "rule " + ruleName + " " + e.Message;
-			NotifyErrorListeners(recognizer, msg, e);
-		}
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        public virtual void ReportFailedPredicate(Parser recognizer, FailedPredicateException
+             e)
+        {
+            string ruleName = recognizer.GetRuleNames()[recognizer._ctx.GetRuleIndex()];
+            string msg = "rule " + ruleName + " " + e.Message;
+            NotifyErrorListeners(recognizer, msg, e);
+        }
 
-		public virtual void ReportUnwantedToken(Parser recognizer)
-		{
-			if (errorRecoveryMode)
-			{
-				return;
-			}
-			recognizer._syntaxErrors++;
-			BeginErrorCondition(recognizer);
-			IToken t = recognizer.GetCurrentToken();
-			string tokenName = GetTokenErrorDisplay(t);
-			IntervalSet expecting = GetExpectedTokens(recognizer);
-			string msg = "extraneous input " + tokenName + " expecting " + expecting.ToString
-				(recognizer.GetTokenNames());
-			recognizer.NotifyErrorListeners(t, msg, null);
-		}
+        public virtual void ReportUnwantedToken(Parser recognizer)
+        {
+            if (errorRecoveryMode)
+            {
+                return;
+            }
+            recognizer._syntaxErrors++;
+            BeginErrorCondition(recognizer);
+            IToken t = recognizer.GetCurrentToken();
+            string tokenName = GetTokenErrorDisplay(t);
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            string msg = "extraneous input " + tokenName + " expecting " + expecting.ToString
+                (recognizer.GetTokenNames());
+            recognizer.NotifyErrorListeners(t, msg, null);
+        }
 
-		public virtual void ReportMissingToken(Parser recognizer)
-		{
-			if (errorRecoveryMode)
-			{
-				return;
-			}
-			recognizer._syntaxErrors++;
-			BeginErrorCondition(recognizer);
-			IToken t = recognizer.GetCurrentToken();
-			IntervalSet expecting = GetExpectedTokens(recognizer);
-			string msg = "missing " + expecting.ToString(recognizer.GetTokenNames()) + " at "
-				 + GetTokenErrorDisplay(t);
-			recognizer.NotifyErrorListeners(t, msg, null);
-		}
+        public virtual void ReportMissingToken(Parser recognizer)
+        {
+            if (errorRecoveryMode)
+            {
+                return;
+            }
+            recognizer._syntaxErrors++;
+            BeginErrorCondition(recognizer);
+            IToken t = recognizer.GetCurrentToken();
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            string msg = "missing " + expecting.ToString(recognizer.GetTokenNames()) + " at "
+                 + GetTokenErrorDisplay(t);
+            recognizer.NotifyErrorListeners(t, msg, null);
+        }
 
-		/// <summary>Attempt to recover from a single missing or extra token.</summary>
-		/// <remarks>
-		/// Attempt to recover from a single missing or extra token.
-		/// EXTRA TOKEN
-		/// LA(1) is not what we are looking for.  If LA(2) has the right token,
-		/// however, then assume LA(1) is some extra spurious token.  Delete it
-		/// and LA(2) as if we were doing a normal match(), which advances the
-		/// input.
-		/// MISSING TOKEN
-		/// If current token is consistent with what could come after
-		/// ttype then it is ok to "insert" the missing token, else throw
-		/// exception For example, Input "i=(3;" is clearly missing the
-		/// ')'.  When the parser returns from the nested call to expr, it
-		/// will have call chain:
-		/// stat -&gt; expr -&gt; atom
-		/// and it will be trying to match the ')' at this point in the
-		/// derivation:
-		/// =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
-		/// ^
-		/// match() will see that ';' doesn't match ')' and report a
-		/// mismatched token error.  To recover, it sees that LA(1)==';'
-		/// is in the set of tokens that can follow the ')' token
-		/// reference in rule atom.  It can assume that you forgot the ')'.
-		/// </remarks>
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		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>Attempt to recover from a single missing or extra token.</summary>
+        /// <remarks>
+        /// Attempt to recover from a single missing or extra token.
+        /// EXTRA TOKEN
+        /// LA(1) is not what we are looking for.  If LA(2) has the right token,
+        /// however, then assume LA(1) is some extra spurious token.  Delete it
+        /// and LA(2) as if we were doing a normal match(), which advances the
+        /// input.
+        /// MISSING TOKEN
+        /// If current token is consistent with what could come after
+        /// ttype then it is ok to "insert" the missing token, else throw
+        /// exception For example, Input "i=(3;" is clearly missing the
+        /// ')'.  When the parser returns from the nested call to expr, it
+        /// will have call chain:
+        /// stat -&gt; expr -&gt; atom
+        /// and it will be trying to match the ')' at this point in the
+        /// derivation:
+        /// =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+        /// ^
+        /// match() will see that ';' doesn't match ')' and report a
+        /// mismatched token error.  To recover, it sees that LA(1)==';'
+        /// is in the set of tokens that can follow the ')' token
+        /// reference in rule atom.  It can assume that you forgot the ')'.
+        /// </remarks>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        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);
+        }
 
-		// if next token is what we are looking for then "delete" this token
-		public virtual bool SingleTokenInsertion(Parser recognizer)
-		{
-			int currentSymbolType = ((ITokenStream)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
-			// is free to conjure up and insert the missing token
-			ATNState currentState = recognizer.GetInterpreter().atn.states[recognizer.GetState
-				()];
-			ATNState next = currentState.Transition(0).target;
-			ATN atn = recognizer.GetInterpreter().atn;
-			IntervalSet expectingAtLL2 = atn.NextTokens(next, PredictionContext.FromRuleContext
-				(atn, recognizer._ctx));
-			//		System.out.println("LT(2) set="+expectingAtLL2.toString(recognizer.getTokenNames()));
-			if (expectingAtLL2.Contains(currentSymbolType))
-			{
-				ReportMissingToken(recognizer);
-				return true;
-			}
-			return false;
-		}
+        // if next token is what we are looking for then "delete" this token
+        public virtual bool SingleTokenInsertion(Parser recognizer)
+        {
+            int currentSymbolType = ((ITokenStream)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
+            // is free to conjure up and insert the missing token
+            ATNState currentState = recognizer.GetInterpreter().atn.states[recognizer.GetState
+                ()];
+            ATNState next = currentState.Transition(0).target;
+            ATN atn = recognizer.GetInterpreter().atn;
+            IntervalSet expectingAtLL2 = atn.NextTokens(next, PredictionContext.FromRuleContext
+                (atn, recognizer._ctx));
+            //		System.out.println("LT(2) set="+expectingAtLL2.toString(recognizer.getTokenNames()));
+            if (expectingAtLL2.Contains(currentSymbolType))
+            {
+                ReportMissingToken(recognizer);
+                return true;
+            }
+            return false;
+        }
 
-		public virtual IToken SingleTokenDeletion(Parser recognizer)
-		{
-			int nextTokenType = ((ITokenStream)recognizer.GetInputStream()).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.GetCurrentToken();
-				EndErrorCondition(recognizer);
-				// we know current token is correct
-				return matchedSymbol;
-			}
-			return null;
-		}
+        public virtual IToken SingleTokenDeletion(Parser recognizer)
+        {
+            int nextTokenType = ((ITokenStream)recognizer.GetInputStream()).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.GetCurrentToken();
+                EndErrorCondition(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>
-		protected internal virtual IToken GetMissingSymbol(Parser recognizer)
-		{
-			IToken currentSymbol = recognizer.GetCurrentToken();
-			IntervalSet expecting = GetExpectedTokens(recognizer);
-			int expectedTokenType = expecting.GetMinElement();
-			// get any element
-			string tokenText;
-			if (expectedTokenType == IToken.Eof)
-			{
-				tokenText = "<missing EOF>";
-			}
-			else
-			{
-				tokenText = "<missing " + recognizer.GetTokenNames()[expectedTokenType] + ">";
-			}
-			IToken current = currentSymbol;
-			IToken lookback = ((ITokenStream)recognizer.GetInputStream()).Lt(-1);
-			if (current.Type == IToken.Eof && lookback != null)
-			{
-				current = lookback;
-			}
-			return ConstructToken(((ITokenStream)recognizer.GetInputStream()).TokenSource, expectedTokenType
-				, tokenText, current);
-		}
+        /// <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>
+        protected internal virtual IToken GetMissingSymbol(Parser recognizer)
+        {
+            IToken currentSymbol = recognizer.GetCurrentToken();
+            IntervalSet expecting = GetExpectedTokens(recognizer);
+            int expectedTokenType = expecting.GetMinElement();
+            // get any element
+            string tokenText;
+            if (expectedTokenType == IToken.Eof)
+            {
+                tokenText = "<missing EOF>";
+            }
+            else
+            {
+                tokenText = "<missing " + recognizer.GetTokenNames()[expectedTokenType] + ">";
+            }
+            IToken current = currentSymbol;
+            IToken lookback = ((ITokenStream)recognizer.GetInputStream()).Lt(-1);
+            if (current.Type == IToken.Eof && lookback != null)
+            {
+                current = lookback;
+            }
+            return ConstructToken(((ITokenStream)recognizer.GetInputStream()).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, IToken.DefaultChannel, -1, -1, current.Line, current
-				.Column);
-		}
+        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, IToken.DefaultChannel, -1, -1, current.Line, current
+                .Column);
+        }
 
-		public virtual IntervalSet GetExpectedTokens(Parser recognizer)
-		{
-			return recognizer.GetExpectedTokens();
-		}
+        public 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>
-		public virtual string GetTokenErrorDisplay(IToken t)
-		{
-			if (t == null)
-			{
-				return "<no token>";
-			}
-			string s = GetSymbolText(t);
-			if (s == null)
-			{
-				if (GetSymbolType(t) == IToken.Eof)
-				{
-					s = "<EOF>";
-				}
-				else
-				{
-					s = "<" + GetSymbolType(t) + ">";
-				}
-			}
-			return EscapeWSAndQuote(s);
-		}
+        /// <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>
+        public virtual string GetTokenErrorDisplay(IToken t)
+        {
+            if (t == null)
+            {
+                return "<no token>";
+            }
+            string s = GetSymbolText(t);
+            if (s == null)
+            {
+                if (GetSymbolType(t) == IToken.Eof)
+                {
+                    s = "<EOF>";
+                }
+                else
+                {
+                    s = "<" + GetSymbolType(t) + ">";
+                }
+            }
+            return EscapeWSAndQuote(s);
+        }
 
-		protected internal virtual string GetSymbolText(IToken symbol)
-		{
-			return symbol.Text;
-		}
+        protected internal virtual string GetSymbolText(IToken symbol)
+        {
+            return symbol.Text;
+        }
 
-		protected internal virtual int GetSymbolType(IToken symbol)
-		{
-			return symbol.Type;
-		}
+        protected internal virtual int GetSymbolType(IToken symbol)
+        {
+            return symbol.Type;
+        }
 
-		protected internal virtual string EscapeWSAndQuote(string s)
-		{
-			//		if ( s==null ) return s;
-			s = s.ReplaceAll("\n", "\\\\n");
-			s = s.ReplaceAll("\r", "\\\\r");
-			s = s.ReplaceAll("\t", "\\\\t");
-			return "'" + s + "'";
-		}
+        protected internal virtual string EscapeWSAndQuote(string s)
+        {
+            //		if ( s==null ) return s;
+            s = s.ReplaceAll("\n", "\\\\n");
+            s = s.ReplaceAll("\r", "\\\\r");
+            s = s.ReplaceAll("\t", "\\\\t");
+            return "'" + s + "'";
+        }
 
-		protected internal virtual IntervalSet GetErrorRecoverySet(Parser recognizer)
-		{
-			ATN atn = recognizer.GetInterpreter().atn;
-			RuleContext ctx = recognizer._ctx;
-			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(IToken.Epsilon);
-			//		System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames()));
-			return recoverSet;
-		}
+        protected internal virtual IntervalSet GetErrorRecoverySet(Parser recognizer)
+        {
+            ATN atn = recognizer.GetInterpreter().atn;
+            RuleContext ctx = recognizer._ctx;
+            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(IToken.Epsilon);
+            //		System.out.println("recover set "+recoverSet.toString(recognizer.getTokenNames()));
+            return recoverSet;
+        }
 
-		/// <summary>Consume tokens until one matches the given token set</summary>
-		public virtual void ConsumeUntil(Parser recognizer, IntervalSet set)
-		{
-			//		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
-			int ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
-			while (ttype != IToken.Eof && !set.Contains(ttype))
-			{
-				//System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
-				//			recognizer.getInputStream().consume();
-				recognizer.Consume();
-				ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
-			}
-		}
-	}
+        /// <summary>Consume tokens until one matches the given token set</summary>
+        public virtual void ConsumeUntil(Parser recognizer, IntervalSet set)
+        {
+            //		System.err.println("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
+            int ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
+            while (ttype != IToken.Eof && !set.Contains(ttype))
+            {
+                //System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
+                //			recognizer.getInputStream().consume();
+                recognizer.Consume();
+                ttype = ((ITokenStream)recognizer.GetInputStream()).La(1);
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Dependents.cs b/Antlr4.Runtime/Dependents.cs
index 84957329e..dfa3e2a26 100644
--- a/Antlr4.Runtime/Dependents.cs
+++ b/Antlr4.Runtime/Dependents.cs
@@ -32,18 +32,18 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <author>Sam Harwell</author>
-	public enum Dependents
-	{
-		Self,
-		Parents,
-		Children,
-		Ancestors,
-		Descendants,
-		Siblings,
-		PreceedingSiblings,
-		FollowingSiblings,
-		Preceeding,
-		Following
-	}
+    /// <author>Sam Harwell</author>
+    public enum Dependents
+    {
+        Self,
+        Parents,
+        Children,
+        Ancestors,
+        Descendants,
+        Siblings,
+        PreceedingSiblings,
+        FollowingSiblings,
+        Preceeding,
+        Following
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs b/Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs
index fbb41e9e3..61a521716 100644
--- a/Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs
+++ b/Antlr4.Runtime/Dfa/AbstractEdgeMap`1.cs
@@ -34,84 +34,84 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
-	/// <author>Sam Harwell</author>
-	public abstract class AbstractEdgeMap<T> : IEdgeMap<T>
-	{
-		protected internal readonly int minIndex;
+    /// <author>Sam Harwell</author>
+    public abstract class AbstractEdgeMap<T> : IEdgeMap<T>
+    {
+        protected internal readonly int minIndex;
 
-		protected internal readonly int maxIndex;
+        protected internal readonly int maxIndex;
 
-		public 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 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);
+        public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Put(int key, T value);
 
-		public virtual Antlr4.Runtime.Dfa.AbstractEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m)
-			 where _T0:T
-		{
-			Antlr4.Runtime.Dfa.AbstractEdgeMap<T> result = this;
-			foreach (KeyValuePair<int, T> entry in m.EntrySet())
-			{
-				result = result.Put(entry.Key, entry.Value);
-			}
-			return result;
-		}
+        public virtual Antlr4.Runtime.Dfa.AbstractEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m)
+             where _T0:T
+        {
+            Antlr4.Runtime.Dfa.AbstractEdgeMap<T> result = this;
+            foreach (KeyValuePair<int, T> entry in m.EntrySet())
+            {
+                result = result.Put(entry.Key, entry.Value);
+            }
+            return result;
+        }
 
-		public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Clear();
+        public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Clear();
 
-		public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Remove(int key);
+        public abstract Antlr4.Runtime.Dfa.AbstractEdgeMap<T> Remove(int key);
 
-		protected internal abstract class AbstractEntrySet : AbstractSet<KeyValuePair<int
-			, T>>
-		{
-			public override bool Contains(object o)
-			{
-				if (!(o is DictionaryEntry))
-				{
-					return false;
-				}
-				KeyValuePair<object, object> entry = (KeyValuePair<object, object>)o;
-				if (entry.Key is int)
-				{
-					int key = (int)entry.Key;
-					object value = entry.Value;
-					T existing = this._enclosing._enclosing.Get(key);
-					return value == existing || (existing != null && existing.Equals(value));
-				}
-				return false;
-			}
+        protected internal abstract class AbstractEntrySet : AbstractSet<KeyValuePair<int
+            , T>>
+        {
+            public override bool Contains(object o)
+            {
+                if (!(o is DictionaryEntry))
+                {
+                    return false;
+                }
+                KeyValuePair<object, object> entry = (KeyValuePair<object, object>)o;
+                if (entry.Key is int)
+                {
+                    int key = (int)entry.Key;
+                    object value = entry.Value;
+                    T existing = this._enclosing._enclosing.Get(key);
+                    return value == existing || (existing != null && existing.Equals(value));
+                }
+                return false;
+            }
 
-			public override int Count
-			{
-				get
-				{
-					return this._enclosing._enclosing.Size();
-				}
-			}
+            public override int Count
+            {
+                get
+                {
+                    return this._enclosing._enclosing.Size();
+                }
+            }
 
-			internal AbstractEntrySet(AbstractEdgeMap<T> _enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal AbstractEntrySet(AbstractEdgeMap<T> _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly AbstractEdgeMap<T> _enclosing;
-		}
+            private readonly AbstractEdgeMap<T> _enclosing;
+        }
 
-		public abstract bool ContainsKey(int arg1);
+        public abstract bool ContainsKey(int arg1);
 
-		public abstract ICollection<KeyValuePair<int, T>> EntrySet();
+        public abstract ICollection<KeyValuePair<int, T>> EntrySet();
 
-		public abstract T Get(int arg1);
+        public abstract T Get(int arg1);
 
-		public abstract bool IsEmpty();
+        public abstract bool IsEmpty();
 
-		public abstract int Size();
+        public abstract int Size();
 
-		public abstract IDictionary<int, T> ToMap();
-	}
+        public abstract IDictionary<int, T> ToMap();
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs b/Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs
index 8485a9b6d..67915ef61 100644
--- a/Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs
+++ b/Antlr4.Runtime/Dfa/ArrayEdgeMap`1.cs
@@ -34,239 +34,239 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
-	/// <author>sam</author>
-	public class ArrayEdgeMap<T> : AbstractEdgeMap<T>
-	{
-		private readonly T[] arrayData;
+    /// <author>sam</author>
+    public class ArrayEdgeMap<T> : AbstractEdgeMap<T>
+    {
+        private readonly T[] arrayData;
 
-		private int size;
+        private int size;
 
-		public ArrayEdgeMap(int minIndex, int maxIndex) : base(minIndex, maxIndex)
-		{
-			arrayData = (T[])new object[maxIndex - minIndex + 1];
-		}
+        public ArrayEdgeMap(int minIndex, int maxIndex) : base(minIndex, maxIndex)
+        {
+            arrayData = (T[])new object[maxIndex - minIndex + 1];
+        }
 
-		public override int Size()
-		{
-			return size;
-		}
+        public override int Size()
+        {
+            return size;
+        }
 
-		public override bool IsEmpty()
-		{
-			return size == 0;
-		}
+        public override bool IsEmpty()
+        {
+            return size == 0;
+        }
 
-		public override bool ContainsKey(int key)
-		{
-			return Get(key) != null;
-		}
+        public override bool ContainsKey(int key)
+        {
+            return Get(key) != null;
+        }
 
-		public override T Get(int key)
-		{
-			if (key < minIndex || key > maxIndex)
-			{
-				return null;
-			}
-			return arrayData[key - minIndex];
-		}
+        public override T Get(int key)
+        {
+            if (key < minIndex || key > maxIndex)
+            {
+                return null;
+            }
+            return arrayData[key - minIndex];
+        }
 
-		public override AbstractEdgeMap<T> Put(int key, T value)
-		{
-			if (key >= minIndex && key <= maxIndex)
-			{
-				T existing = arrayData[key - minIndex];
-				arrayData[key - minIndex] = value;
-				if (existing == null && value != null)
-				{
-					size++;
-				}
-				else
-				{
-					if (existing != null && value == null)
-					{
-						size--;
-					}
-				}
-			}
-			return this;
-		}
+        public override AbstractEdgeMap<T> Put(int key, T value)
+        {
+            if (key >= minIndex && key <= maxIndex)
+            {
+                T existing = arrayData[key - minIndex];
+                arrayData[key - minIndex] = value;
+                if (existing == null && value != null)
+                {
+                    size++;
+                }
+                else
+                {
+                    if (existing != null && value == null)
+                    {
+                        size--;
+                    }
+                }
+            }
+            return this;
+        }
 
-		public override AbstractEdgeMap<T> Remove(int key)
-		{
-			return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(key, null));
-		}
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(key, null));
+        }
 
-		public override AbstractEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m)
-		{
-			if (m.IsEmpty())
-			{
-				return this;
-			}
-			if (m is Antlr4.Runtime.Dfa.ArrayEdgeMap<object>)
-			{
-				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);
-				for (int i = minOverlap; i <= maxOverlap; i++)
-				{
-					T target = other.arrayData[i - other.minIndex];
-					if (target != null)
-					{
-						T current = this.arrayData[i - this.minIndex];
-						this.arrayData[i - this.minIndex] = target;
-						size += (current != null ? 0 : 1);
-					}
-				}
-				return this;
-			}
-			else
-			{
-				if (m is SingletonEdgeMap<object>)
-				{
-					SingletonEdgeMap<T> other = (SingletonEdgeMap<T>)m;
-					System.Diagnostics.Debug.Assert(!other.IsEmpty());
-					return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(other.GetKey(), other.GetValue())
-						);
-				}
-				else
-				{
-					if (m is SparseEdgeMap<object>)
-					{
-						SparseEdgeMap<T> other = (SparseEdgeMap<T>)m;
-						int[] keys = other.GetKeys();
-						IList<T> values = other.GetValues();
-						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 %s is supported yet."
-							, m.GetType().FullName));
-					}
-				}
-			}
-		}
+        public override AbstractEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m)
+        {
+            if (m.IsEmpty())
+            {
+                return this;
+            }
+            if (m is Antlr4.Runtime.Dfa.ArrayEdgeMap<object>)
+            {
+                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);
+                for (int i = minOverlap; i <= maxOverlap; i++)
+                {
+                    T target = other.arrayData[i - other.minIndex];
+                    if (target != null)
+                    {
+                        T current = this.arrayData[i - this.minIndex];
+                        this.arrayData[i - this.minIndex] = target;
+                        size += (current != null ? 0 : 1);
+                    }
+                }
+                return this;
+            }
+            else
+            {
+                if (m is SingletonEdgeMap<object>)
+                {
+                    SingletonEdgeMap<T> other = (SingletonEdgeMap<T>)m;
+                    System.Diagnostics.Debug.Assert(!other.IsEmpty());
+                    return ((Antlr4.Runtime.Dfa.ArrayEdgeMap<T>)Put(other.GetKey(), other.GetValue())
+                        );
+                }
+                else
+                {
+                    if (m is SparseEdgeMap<object>)
+                    {
+                        SparseEdgeMap<T> other = (SparseEdgeMap<T>)m;
+                        int[] keys = other.GetKeys();
+                        IList<T> values = other.GetValues();
+                        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 %s is supported yet."
+                            , m.GetType().FullName));
+                    }
+                }
+            }
+        }
 
-		public override AbstractEdgeMap<T> Clear()
-		{
-			Arrays.Fill(arrayData, null);
-			return this;
-		}
+        public override AbstractEdgeMap<T> Clear()
+        {
+            Arrays.Fill(arrayData, null);
+            return this;
+        }
 
-		public override IDictionary<int, T> ToMap()
-		{
-			if (IsEmpty())
-			{
-				return Sharpen.Collections.EmptyMap();
-			}
-			IDictionary<int, T> result = new LinkedHashMap<int, T>();
-			for (int i = 0; i < arrayData.Length; i++)
-			{
-				if (arrayData[i] == null)
-				{
-					continue;
-				}
-				result.Put(i + minIndex, arrayData[i]);
-			}
-			return result;
-		}
+        public override IDictionary<int, T> ToMap()
+        {
+            if (IsEmpty())
+            {
+                return Sharpen.Collections.EmptyMap();
+            }
+            IDictionary<int, T> result = new LinkedHashMap<int, T>();
+            for (int i = 0; i < arrayData.Length; i++)
+            {
+                if (arrayData[i] == null)
+                {
+                    continue;
+                }
+                result.Put(i + minIndex, arrayData[i]);
+            }
+            return result;
+        }
 
-		public override ICollection<KeyValuePair<int, T>> EntrySet()
-		{
-			return new ArrayEdgeMap.EntrySet(this);
-		}
+        public override ICollection<KeyValuePair<int, T>> EntrySet()
+        {
+            return new ArrayEdgeMap.EntrySet(this);
+        }
 
-		private class EntrySet : AbstractEdgeMap.AbstractEntrySet
-		{
-			public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
-			{
-				return new ArrayEdgeMap.EntryIterator(this);
-			}
+        private class EntrySet : AbstractEdgeMap.AbstractEntrySet
+        {
+            public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+            {
+                return new ArrayEdgeMap.EntryIterator(this);
+            }
 
-			internal EntrySet(ArrayEdgeMap<T> _enclosing) : base(_enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal EntrySet(ArrayEdgeMap<T> _enclosing) : base(_enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly ArrayEdgeMap<T> _enclosing;
-		}
+            private readonly ArrayEdgeMap<T> _enclosing;
+        }
 
-		private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
-		{
-			private int current;
+        private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
+        {
+            private int current;
 
-			private int currentIndex;
+            private int currentIndex;
 
-			public override bool HasNext()
-			{
-				return this.current < this._enclosing.Size();
-			}
+            public override bool HasNext()
+            {
+                return this.current < this._enclosing.Size();
+            }
 
-			public override KeyValuePair<int, T> Next()
-			{
-				if (this.current >= this._enclosing.Size())
-				{
-					throw new NoSuchElementException();
-				}
-				while (this._enclosing.arrayData[this.currentIndex] == null)
-				{
-					this.currentIndex++;
-				}
-				this.current++;
-				this.currentIndex++;
-				return new _KeyValuePair_193(this);
-			}
+            public override KeyValuePair<int, T> Next()
+            {
+                if (this.current >= this._enclosing.Size())
+                {
+                    throw new NoSuchElementException();
+                }
+                while (this._enclosing.arrayData[this.currentIndex] == null)
+                {
+                    this.currentIndex++;
+                }
+                this.current++;
+                this.currentIndex++;
+                return new _KeyValuePair_193(this);
+            }
 
-			private sealed class _KeyValuePair_193 : KeyValuePair<int, T>
-			{
-				public _KeyValuePair_193()
-				{
-					this.key = this._enclosing._enclosing.minIndex + this._enclosing.currentIndex - 1;
-					this.value = this._enclosing._enclosing.arrayData[this._enclosing.currentIndex - 
-						1];
-				}
+            private sealed class _KeyValuePair_193 : KeyValuePair<int, T>
+            {
+                public _KeyValuePair_193()
+                {
+                    this.key = this._enclosing._enclosing.minIndex + this._enclosing.currentIndex - 1;
+                    this.value = this._enclosing._enclosing.arrayData[this._enclosing.currentIndex - 
+                        1];
+                }
 
-				private readonly int key;
+                private readonly int key;
 
-				private readonly T value;
+                private readonly T value;
 
-				public int Key
-				{
-					get
-					{
-						return this.key;
-					}
-				}
+                public int Key
+                {
+                    get
+                    {
+                        return this.key;
+                    }
+                }
 
-				public T Value
-				{
-					get
-					{
-						return this.value;
-					}
-				}
+                public T Value
+                {
+                    get
+                    {
+                        return this.value;
+                    }
+                }
 
-				public T SetValue(T value)
-				{
-					throw new NotSupportedException("Not supported yet.");
-				}
-			}
+                public T SetValue(T value)
+                {
+                    throw new NotSupportedException("Not supported yet.");
+                }
+            }
 
-			public override void Remove()
-			{
-				throw new NotSupportedException("Not supported yet.");
-			}
+            public override void Remove()
+            {
+                throw new NotSupportedException("Not supported yet.");
+            }
 
-			internal EntryIterator(ArrayEdgeMap<T> _enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal EntryIterator(ArrayEdgeMap<T> _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly ArrayEdgeMap<T> _enclosing;
-		}
-	}
+            private readonly ArrayEdgeMap<T> _enclosing;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/DFA.cs b/Antlr4.Runtime/Dfa/DFA.cs
index 8335f0d43..543ec7432 100644
--- a/Antlr4.Runtime/Dfa/DFA.cs
+++ b/Antlr4.Runtime/Dfa/DFA.cs
@@ -34,111 +34,111 @@ using Sharpen;
 
 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.IDictionary{K, V}">System.Collections.IDictionary&lt;K, V&gt;
-		/// 	</see>
-		/// so we can get old state back
-		/// (
-		/// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
-		/// only allows you to see if it's there).
-		/// </remarks>
-		[NotNull]
-		public readonly IConcurrentMap<DFAState, DFAState> states = new ConcurrentHashMap
-			<DFAState, DFAState>();
+    public class DFA
+    {
+        /// <summary>A set of all DFA states.</summary>
+        /// <remarks>
+        /// A set of all DFA states. Use
+        /// <see cref="System.Collections.IDictionary{K, V}">System.Collections.IDictionary&lt;K, V&gt;
+        ///     </see>
+        /// so we can get old state back
+        /// (
+        /// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
+        /// only allows you to see if it's there).
+        /// </remarks>
+        [NotNull]
+        public readonly IConcurrentMap<DFAState, DFAState> states = new ConcurrentHashMap
+            <DFAState, DFAState>();
 
-		[Nullable]
-		public readonly AtomicReference<DFAState> s0 = new AtomicReference<DFAState>();
+        [Nullable]
+        public readonly AtomicReference<DFAState> s0 = new AtomicReference<DFAState>();
 
-		[Nullable]
-		public readonly AtomicReference<DFAState> s0full = new AtomicReference<DFAState>(
-			);
+        [Nullable]
+        public readonly AtomicReference<DFAState> s0full = new AtomicReference<DFAState>(
+            );
 
-		public readonly int decision;
+        public readonly int decision;
 
-		/// <summary>From which ATN state did we create this DFA?</summary>
-		[NotNull]
-		public readonly ATNState atnStartState;
+        /// <summary>From which ATN state did we create this DFA?</summary>
+        [NotNull]
+        public readonly ATNState atnStartState;
 
-		private readonly AtomicInteger nextStateNumber = new AtomicInteger();
+        private readonly AtomicInteger nextStateNumber = new AtomicInteger();
 
-		/// <summary>
-		/// Set of configs for a DFA state with at least one conflict? Mainly used as "return value"
-		/// from
-		/// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
-		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
-		/// 	</see>
-		/// for retry.
-		/// </summary>
-		public DFA(ATNState atnStartState) : this(atnStartState, 0)
-		{
-		}
+        /// <summary>
+        /// Set of configs for a DFA state with at least one conflict? Mainly used as "return value"
+        /// from
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+        ///     ">Antlr4.Runtime.Atn.ParserATNSimulator.PredictATN(DFA, Antlr4.Runtime.ITokenStream, Antlr4.Runtime.ParserRuleContext, bool)
+        ///     </see>
+        /// for retry.
+        /// </summary>
+        public DFA(ATNState atnStartState) : this(atnStartState, 0)
+        {
+        }
 
-		public DFA(ATNState atnStartState, int decision)
-		{
-			//	public OrderedHashSet<ATNConfig> conflictSet;
-			this.atnStartState = atnStartState;
-			this.decision = decision;
-		}
+        public DFA(ATNState atnStartState, int decision)
+        {
+            //	public OrderedHashSet<ATNConfig> conflictSet;
+            this.atnStartState = atnStartState;
+            this.decision = decision;
+        }
 
-		public virtual bool IsEmpty()
-		{
-			return s0.Get() == null && s0full.Get() == null;
-		}
+        public virtual bool IsEmpty()
+        {
+            return s0.Get() == null && s0full.Get() == null;
+        }
 
-		public virtual bool IsContextSensitive()
-		{
-			return s0full.Get() != null;
-		}
+        public virtual bool IsContextSensitive()
+        {
+            return s0full.Get() != null;
+        }
 
-		public virtual DFAState AddState(DFAState state)
-		{
-			state.stateNumber = nextStateNumber.GetAndIncrement();
-			DFAState existing = states.PutIfAbsent(state, state);
-			if (existing != null)
-			{
-				return existing;
-			}
-			return state;
-		}
+        public virtual DFAState AddState(DFAState state)
+        {
+            state.stateNumber = nextStateNumber.GetAndIncrement();
+            DFAState existing = states.PutIfAbsent(state, state);
+            if (existing != null)
+            {
+                return existing;
+            }
+            return state;
+        }
 
-		public override string ToString()
-		{
-			return ToString(null);
-		}
+        public override string ToString()
+        {
+            return ToString(null);
+        }
 
-		public virtual string ToString(string[] tokenNames)
-		{
-			if (s0.Get() == null)
-			{
-				return string.Empty;
-			}
-			DFASerializer serializer = new DFASerializer(this, tokenNames);
-			return serializer.ToString();
-		}
+        public virtual string ToString(string[] tokenNames)
+        {
+            if (s0.Get() == null)
+            {
+                return string.Empty;
+            }
+            DFASerializer serializer = new DFASerializer(this, tokenNames);
+            return serializer.ToString();
+        }
 
-		public virtual string ToString(string[] tokenNames, string[] ruleNames)
-		{
-			if (s0.Get() == null)
-			{
-				return string.Empty;
-			}
-			DFASerializer serializer = new DFASerializer(this, tokenNames, ruleNames, atnStartState
-				.atn);
-			return serializer.ToString();
-		}
+        public virtual string ToString(string[] tokenNames, string[] ruleNames)
+        {
+            if (s0.Get() == null)
+            {
+                return string.Empty;
+            }
+            DFASerializer serializer = new DFASerializer(this, tokenNames, 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();
-		}
-	}
+        public virtual string ToLexerString()
+        {
+            if (s0.Get() == null)
+            {
+                return string.Empty;
+            }
+            DFASerializer serializer = new LexerDFASerializer(this);
+            return serializer.ToString();
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/DFASerializer.cs b/Antlr4.Runtime/Dfa/DFASerializer.cs
index cb0b8b4b6..44a064c18 100644
--- a/Antlr4.Runtime/Dfa/DFASerializer.cs
+++ b/Antlr4.Runtime/Dfa/DFASerializer.cs
@@ -37,186 +37,186 @@ using 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]
-		internal readonly DFA 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]
+        internal readonly DFA dfa;
 
-		[Nullable]
-		internal readonly string[] tokenNames;
+        [Nullable]
+        internal readonly string[] tokenNames;
 
-		[Nullable]
-		internal readonly string[] ruleNames;
+        [Nullable]
+        internal readonly string[] ruleNames;
 
-		[Nullable]
-		internal readonly ATN atn;
+        [Nullable]
+        internal readonly ATN atn;
 
-		public DFASerializer(DFA dfa, string[] tokenNames) : this(dfa, tokenNames, null, 
-			null)
-		{
-		}
+        public DFASerializer(DFA dfa, string[] tokenNames) : this(dfa, tokenNames, null, 
+            null)
+        {
+        }
 
-		public DFASerializer(DFA dfa, Recognizer<object, object> parser) : this(dfa, parser
-			 != null ? parser.GetTokenNames() : null, parser != null ? parser.GetRuleNames()
-			 : null, parser != null ? parser.GetATN() : null)
-		{
-		}
+        public DFASerializer(DFA dfa, Recognizer<object, object> parser) : this(dfa, parser
+             != null ? parser.GetTokenNames() : null, parser != null ? parser.GetRuleNames
+            () : null, parser != null ? parser.GetATN() : null)
+        {
+        }
 
-		public DFASerializer(DFA dfa, string[] tokenNames, string[] ruleNames, ATN atn)
-		{
-			this.dfa = dfa;
-			this.tokenNames = tokenNames;
-			this.ruleNames = ruleNames;
-			this.atn = atn;
-		}
+        public DFASerializer(DFA dfa, string[] tokenNames, string[] ruleNames, ATN atn)
+        {
+            this.dfa = dfa;
+            this.tokenNames = tokenNames;
+            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)
-			{
-				IList<DFAState> states = new List<DFAState>(dfa.states.Values);
-				states.Sort(new _IComparer_85());
-				foreach (DFAState s in states)
-				{
-					IDictionary<int, DFAState> edges = s.EdgeMap;
-					IDictionary<int, DFAState> contextEdges = s.ContextEdgeMap;
-					foreach (KeyValuePair<int, DFAState> entry in edges.EntrySet())
-					{
-						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.EntrySet())
-						{
-							buf.Append(GetStateString(s)).Append("-").Append(GetContextLabel(entry_1.Key)).Append
-								("->").Append(GetStateString(entry_1.Value)).Append("\n");
-						}
-					}
-				}
-			}
-			string output = buf.ToString();
-			//return Utils.sortLinesInString(output);
-			return output;
-		}
+        public override string ToString()
+        {
+            if (dfa.s0.Get() == null)
+            {
+                return null;
+            }
+            StringBuilder buf = new StringBuilder();
+            if (dfa.states != null)
+            {
+                IList<DFAState> states = new List<DFAState>(dfa.states.Values);
+                states.Sort(new _IComparer_85());
+                foreach (DFAState s in states)
+                {
+                    IDictionary<int, DFAState> edges = s.EdgeMap;
+                    IDictionary<int, DFAState> contextEdges = s.ContextEdgeMap;
+                    foreach (KeyValuePair<int, DFAState> entry in edges.EntrySet())
+                    {
+                        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.EntrySet())
+                        {
+                            buf.Append(GetStateString(s)).Append("-").Append(GetContextLabel(entry_1.Key)).Append
+                                ("->").Append(GetStateString(entry_1.Value)).Append("\n");
+                        }
+                    }
+                }
+            }
+            string output = buf.ToString();
+            //return Utils.sortLinesInString(output);
+            return output;
+        }
 
-		private sealed class _IComparer_85 : IComparer<DFAState>
-		{
-			public _IComparer_85()
-			{
-			}
+        private sealed class _IComparer_85 : IComparer<DFAState>
+        {
+            public _IComparer_85()
+            {
+            }
 
-			public int Compare(DFAState o1, DFAState o2)
-			{
-				return o1.stateNumber - o2.stateNumber;
-			}
-		}
+            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 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)
-		{
-			string label;
-			if (i == -1)
-			{
-				return "EOF";
-			}
-			if (tokenNames != null)
-			{
-				label = tokenNames[i];
-			}
-			else
-			{
-				label = i.ToString();
-			}
-			return label;
-		}
+        protected internal virtual string GetEdgeLabel(int i)
+        {
+            string label;
+            if (i == -1)
+            {
+                return "EOF";
+            }
+            if (tokenNames != null)
+            {
+                label = tokenNames[i];
+            }
+            else
+            {
+                label = i.ToString();
+            }
+            return label;
+        }
 
-		internal virtual string GetStateString(DFAState s)
-		{
-			if (s == ATNSimulator.Error)
-			{
-				return "ERROR";
-			}
-			int n = s.stateNumber;
-			string stateStr = "s" + n;
-			if (s.isAcceptState)
-			{
-				if (s.predicates != null)
-				{
-					stateStr = ":s" + n + "=>" + Arrays.ToString(s.predicates);
-				}
-				else
-				{
-					stateStr = ":s" + n + "=>" + s.prediction;
-				}
-			}
-			if (s.IsContextSensitive)
-			{
-				stateStr += "*";
-				foreach (ATNConfig config in s.configs)
-				{
-					if (config.GetReachesIntoOuterContext())
-					{
-						stateStr += "*";
-						break;
-					}
-				}
-			}
-			return stateStr;
-		}
-	}
+        internal virtual string GetStateString(DFAState s)
+        {
+            if (s == ATNSimulator.Error)
+            {
+                return "ERROR";
+            }
+            int n = s.stateNumber;
+            string stateStr = "s" + n;
+            if (s.isAcceptState)
+            {
+                if (s.predicates != null)
+                {
+                    stateStr = ":s" + n + "=>" + Arrays.ToString(s.predicates);
+                }
+                else
+                {
+                    stateStr = ":s" + n + "=>" + s.prediction;
+                }
+            }
+            if (s.IsContextSensitive)
+            {
+                stateStr += "*";
+                foreach (ATNConfig config in s.configs)
+                {
+                    if (config.GetReachesIntoOuterContext())
+                    {
+                        stateStr += "*";
+                        break;
+                    }
+                }
+            }
+            return stateStr;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/DFAState.cs b/Antlr4.Runtime/Dfa/DFAState.cs
index 7aee76338..250977ec9 100644
--- a/Antlr4.Runtime/Dfa/DFAState.cs
+++ b/Antlr4.Runtime/Dfa/DFAState.cs
@@ -37,322 +37,322 @@ using 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-&gt;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/>
-	/// 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.
-	/// </remarks>
-	public class DFAState
-	{
-		public int stateNumber = -1;
+    /// <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-&gt;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/>
+    /// 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.
+    /// </remarks>
+    public class DFAState
+    {
+        public int stateNumber = -1;
 
-		[NotNull]
-		public readonly ATNConfigSet configs;
+        [NotNull]
+        public readonly ATNConfigSet configs;
 
-		/// <summary>
-		/// <code>edges.get(symbol)</code>
-		/// points to target of symbol.
-		/// </summary>
-		[Nullable]
-		private AbstractEdgeMap<Antlr4.Runtime.Dfa.DFAState> edges;
+        /// <summary>
+        /// <code>edges.get(symbol)</code>
+        /// points to target of symbol.
+        /// </summary>
+        [Nullable]
+        private AbstractEdgeMap<Antlr4.Runtime.Dfa.DFAState> edges;
 
-		private readonly int minSymbol;
+        private readonly int minSymbol;
 
-		private readonly int maxSymbol;
+        private readonly int maxSymbol;
 
-		public bool isAcceptState = false;
+        public bool isAcceptState = false;
 
-		/// <summary>
-		/// if accept state, what ttype do we match or alt do we predict?
-		/// This is set to
-		/// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber">Antlr4.Runtime.Atn.ATN.InvalidAltNumber
-		/// 	</see>
-		/// when
-		/// <see cref="predicates">predicates</see>
-		/// <code>!=null</code>
-		/// .
-		/// </summary>
-		public int prediction;
+        /// <summary>
+        /// if accept state, what ttype do we match or alt do we predict?
+        /// This is set to
+        /// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber">Antlr4.Runtime.Atn.ATN.InvalidAltNumber
+        ///     </see>
+        /// when
+        /// <see cref="predicates">predicates</see>
+        /// <code>!=null</code>
+        /// .
+        /// </summary>
+        public int prediction;
 
-		public int lexerRuleIndex = -1;
+        public int lexerRuleIndex = -1;
 
-		public int lexerActionIndex = -1;
+        public int lexerActionIndex = -1;
 
-		/// <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>
-		[Nullable]
-		private AbstractEdgeMap<Antlr4.Runtime.Dfa.DFAState> contextEdges;
+        /// <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>
+        [Nullable]
+        private 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>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)
-		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)
-		/// 	</see>
-		/// .
-		/// </summary>
-		[Nullable]
-		public DFAState.PredPrediction[] predicates;
+        /// <summary>
+        /// This list is computed by
+        /// <see cref="Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)
+        ///     ">Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(DFAState, Antlr4.Runtime.Atn.ATNConfigSet, int)
+        ///     </see>
+        /// .
+        /// </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;
+        /// <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 int alt;
 
-			public PredPrediction(SemanticContext pred, int alt)
-			{
-				// if accept, exec action in what rule?
-				// if accept, exec what action?
-				// never null; at least SemanticContext.NONE
-				this.alt = alt;
-				this.pred = pred;
-			}
+            public PredPrediction(SemanticContext pred, int alt)
+            {
+                // if accept, exec action in what rule?
+                // if accept, exec what action?
+                // never null; at least SemanticContext.NONE
+                this.alt = alt;
+                this.pred = pred;
+            }
 
-			public override string ToString()
-			{
-				return "(" + pred + ", " + alt + ")";
-			}
-		}
+            public override string ToString()
+            {
+                return "(" + pred + ", " + alt + ")";
+            }
+        }
 
-		public DFAState(ATNConfigSet configs, int minSymbol, int maxSymbol)
-		{
-			this.configs = configs;
-			this.minSymbol = minSymbol;
-			this.maxSymbol = maxSymbol;
-		}
+        public DFAState(ATNConfigSet configs, int minSymbol, int maxSymbol)
+        {
+            this.configs = configs;
+            this.minSymbol = minSymbol;
+            this.maxSymbol = maxSymbol;
+        }
 
-		public bool IsContextSensitive
-		{
-			get
-			{
-				return contextEdges != null;
-			}
-		}
+        public bool IsContextSensitive
+        {
+            get
+            {
+                return contextEdges != null;
+            }
+        }
 
-		public bool IsContextSymbol(int symbol)
-		{
-			if (!IsContextSensitive || symbol < minSymbol)
-			{
-				return false;
-			}
-			return contextSymbols.Get(symbol - minSymbol);
-		}
+        public bool IsContextSymbol(int symbol)
+        {
+            if (!IsContextSensitive || symbol < minSymbol)
+            {
+                return false;
+            }
+            return contextSymbols.Get(symbol - minSymbol);
+        }
 
-		public void SetContextSymbol(int symbol)
-		{
-			System.Diagnostics.Debug.Assert(IsContextSensitive);
-			if (symbol < minSymbol)
-			{
-				return;
-			}
-			contextSymbols.Set(symbol - minSymbol);
-		}
+        public void SetContextSymbol(int symbol)
+        {
+            System.Diagnostics.Debug.Assert(IsContextSensitive);
+            if (symbol < minSymbol)
+            {
+                return;
+            }
+            contextSymbols.Set(symbol - minSymbol);
+        }
 
-		public virtual void SetContextSensitive(ATN atn)
-		{
-			lock (this)
-			{
-				System.Diagnostics.Debug.Assert(!configs.IsOutermostConfigSet());
-				if (IsContextSensitive)
-				{
-					return;
-				}
-				contextSymbols = new BitSet();
-				contextEdges = new SingletonEdgeMap<DFAState>(-1, atn.states.Count - 1);
-			}
-		}
+        public virtual void SetContextSensitive(ATN atn)
+        {
+            lock (this)
+            {
+                System.Diagnostics.Debug.Assert(!configs.IsOutermostConfigSet());
+                if (IsContextSensitive)
+                {
+                    return;
+                }
+                contextSymbols = new BitSet();
+                contextEdges = new SingletonEdgeMap<DFAState>(-1, atn.states.Count - 1);
+            }
+        }
 
-		public virtual DFAState GetTarget(int symbol)
-		{
-			if (edges == null)
-			{
-				return null;
-			}
-			return edges.Get(symbol);
-		}
+        public virtual DFAState GetTarget(int symbol)
+        {
+            if (edges == null)
+            {
+                return null;
+            }
+            return edges.Get(symbol);
+        }
 
-		public virtual void SetTarget(int symbol, DFAState target)
-		{
-			lock (this)
-			{
-				if (edges == null)
-				{
-					edges = new SingletonEdgeMap<DFAState>(minSymbol, maxSymbol);
-				}
-				edges = edges.Put(symbol, target);
-			}
-		}
+        public virtual void SetTarget(int symbol, DFAState target)
+        {
+            lock (this)
+            {
+                if (edges == null)
+                {
+                    edges = new SingletonEdgeMap<DFAState>(minSymbol, maxSymbol);
+                }
+                edges = edges.Put(symbol, target);
+            }
+        }
 
-		public virtual IDictionary<int, DFAState> EdgeMap
-		{
-			get
-			{
-				if (edges == null)
-				{
-					return Sharpen.Collections.EmptyMap();
-				}
-				return edges.ToMap();
-			}
-		}
+        public virtual IDictionary<int, DFAState> EdgeMap
+        {
+            get
+            {
+                if (edges == null)
+                {
+                    return Sharpen.Collections.EmptyMap();
+                }
+                return edges.ToMap();
+            }
+        }
 
-		public virtual DFAState GetContextTarget(int invokingState)
-		{
-			if (contextEdges == null)
-			{
-				return null;
-			}
-			if (invokingState == PredictionContext.EmptyFullStateKey)
-			{
-				invokingState = -1;
-			}
-			return contextEdges.Get(invokingState);
-		}
+        public virtual DFAState GetContextTarget(int invokingState)
+        {
+            if (contextEdges == null)
+            {
+                return null;
+            }
+            if (invokingState == PredictionContext.EmptyFullStateKey)
+            {
+                invokingState = -1;
+            }
+            return contextEdges.Get(invokingState);
+        }
 
-		public virtual void SetContextTarget(int invokingState, DFAState target)
-		{
-			lock (this)
-			{
-				if (contextEdges == null)
-				{
-					throw new InvalidOperationException("The state is not context sensitive.");
-				}
-				if (invokingState == PredictionContext.EmptyFullStateKey)
-				{
-					invokingState = -1;
-				}
-				contextEdges = contextEdges.Put(invokingState, target);
-			}
-		}
+        public virtual void SetContextTarget(int invokingState, DFAState target)
+        {
+            lock (this)
+            {
+                if (contextEdges == null)
+                {
+                    throw new InvalidOperationException("The state is not context sensitive.");
+                }
+                if (invokingState == PredictionContext.EmptyFullStateKey)
+                {
+                    invokingState = -1;
+                }
+                contextEdges = contextEdges.Put(invokingState, target);
+            }
+        }
 
-		public virtual IDictionary<int, DFAState> ContextEdgeMap
-		{
-			get
-			{
-				if (contextEdges == null)
-				{
-					return Sharpen.Collections.EmptyMap();
-				}
-				IDictionary<int, DFAState> map = contextEdges.ToMap();
-				if (map.ContainsKey(-1))
-				{
-					if (map.Count == 1)
-					{
-						return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.
-							Get(-1));
-					}
-					else
-					{
-						try
-						{
-							map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
-						}
-						catch (NotSupportedException)
-						{
-							// handles read only, non-singleton maps
-							map = new LinkedHashMap<int, DFAState>(map);
-							map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
-						}
-					}
-				}
-				return map;
-			}
-		}
+        public virtual IDictionary<int, DFAState> ContextEdgeMap
+        {
+            get
+            {
+                if (contextEdges == null)
+                {
+                    return Sharpen.Collections.EmptyMap();
+                }
+                IDictionary<int, DFAState> map = contextEdges.ToMap();
+                if (map.ContainsKey(-1))
+                {
+                    if (map.Count == 1)
+                    {
+                        return Sharpen.Collections.SingletonMap(PredictionContext.EmptyFullStateKey, map.
+                            Get(-1));
+                    }
+                    else
+                    {
+                        try
+                        {
+                            map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+                        }
+                        catch (NotSupportedException)
+                        {
+                            // handles read only, non-singleton maps
+                            map = new LinkedHashMap<int, DFAState>(map);
+                            map.Put(PredictionContext.EmptyFullStateKey, Sharpen.Collections.Remove(map, -1));
+                        }
+                    }
+                }
+                return map;
+            }
+        }
 
-		public override int GetHashCode()
-		{
-			if (configs == null)
-			{
-				return 1;
-			}
-			return configs.GetHashCode();
-		}
+        public override int GetHashCode()
+        {
+            if (configs == null)
+            {
+                return 1;
+            }
+            return configs.GetHashCode();
+        }
 
-		/// <summary>
-		/// Two
-		/// <see cref="DFAState">DFAState</see>
-		/// 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/>
-		/// 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)
-		/// 	">Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)
-		/// 	</see>
-		/// we need to know if any other state
-		/// exists that has this exact set of ATN configurations. The
-		/// <see cref="stateNumber">stateNumber</see>
-		/// is irrelevant.
-		/// </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;
-		}
+        /// <summary>
+        /// Two
+        /// <see cref="DFAState">DFAState</see>
+        /// 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/>
+        /// 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)
+        ///     ">Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(DFA, Antlr4.Runtime.Atn.ATNConfigSet, Antlr4.Runtime.Atn.PredictionContextCache)
+        ///     </see>
+        /// we need to know if any other state
+        /// exists that has this exact set of ATN configurations. The
+        /// <see cref="stateNumber">stateNumber</see>
+        /// is irrelevant.
+        /// </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();
-		}
-	}
+        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/Antlr4.Runtime/Dfa/IEdgeMap`1.cs b/Antlr4.Runtime/Dfa/IEdgeMap`1.cs
index 37a7689b1..0ad02e18c 100644
--- a/Antlr4.Runtime/Dfa/IEdgeMap`1.cs
+++ b/Antlr4.Runtime/Dfa/IEdgeMap`1.cs
@@ -34,34 +34,34 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
-	/// <author>Sam Harwell</author>
-	public interface IEdgeMap<T>
-	{
-		int Size();
+    /// <author>Sam Harwell</author>
+    public interface IEdgeMap<T>
+    {
+        int Size();
 
-		bool IsEmpty();
+        bool IsEmpty();
 
-		bool ContainsKey(int key);
+        bool ContainsKey(int key);
 
-		[Nullable]
-		T Get(int key);
+        [Nullable]
+        T Get(int key);
 
-		[NotNull]
-		IEdgeMap<T> Put(int key, T value);
+        [NotNull]
+        IEdgeMap<T> Put(int key, T value);
 
-		[NotNull]
-		IEdgeMap<T> Remove(int key);
+        [NotNull]
+        IEdgeMap<T> Remove(int key);
 
-		[NotNull]
-		IEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m) where _T0:T;
+        [NotNull]
+        IEdgeMap<T> PutAll<_T0>(IEdgeMap<_T0> m) where _T0:T;
 
-		[NotNull]
-		IEdgeMap<T> Clear();
+        [NotNull]
+        IEdgeMap<T> Clear();
 
-		[NotNull]
-		IDictionary<int, T> ToMap();
+        [NotNull]
+        IDictionary<int, T> ToMap();
 
-		[NotNull]
-		ICollection<KeyValuePair<int, T>> EntrySet();
-	}
+        [NotNull]
+        ICollection<KeyValuePair<int, T>> EntrySet();
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/LexerDFASerializer.cs b/Antlr4.Runtime/Dfa/LexerDFASerializer.cs
index 0f6add7b4..8073250ea 100644
--- a/Antlr4.Runtime/Dfa/LexerDFASerializer.cs
+++ b/Antlr4.Runtime/Dfa/LexerDFASerializer.cs
@@ -33,16 +33,16 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
-	public class LexerDFASerializer : DFASerializer
-	{
-		public LexerDFASerializer(DFA dfa) : base(dfa, (string[])null)
-		{
-		}
+    public class LexerDFASerializer : DFASerializer
+    {
+        public LexerDFASerializer(DFA dfa) : base(dfa, (string[])null)
+        {
+        }
 
-		[NotNull]
-		protected internal override string GetEdgeLabel(int i)
-		{
-			return "'" + (char)i + "'";
-		}
-	}
+        [NotNull]
+        protected internal override string GetEdgeLabel(int i)
+        {
+            return "'" + (char)i + "'";
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs b/Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs
index 11c87246a..16706e1b9 100644
--- a/Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs
+++ b/Antlr4.Runtime/Dfa/SingletonEdgeMap`1.cs
@@ -34,205 +34,205 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
-	/// <author>Sam Harwell</author>
-	public class SingletonEdgeMap<T> : AbstractEdgeMap<T>
-	{
-		private readonly int key;
+    /// <author>Sam Harwell</author>
+    public class SingletonEdgeMap<T> : AbstractEdgeMap<T>
+    {
+        private readonly int key;
 
-		private readonly T value;
+        private readonly T value;
 
-		public SingletonEdgeMap(int minIndex, int maxIndex) : base(minIndex, maxIndex)
-		{
-			this.key = 0;
-			this.value = null;
-		}
+        public SingletonEdgeMap(int minIndex, int maxIndex) : base(minIndex, maxIndex)
+        {
+            this.key = 0;
+            this.value = null;
+        }
 
-		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 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 virtual int GetKey()
-		{
-			return key;
-		}
+        public virtual int GetKey()
+        {
+            return key;
+        }
 
-		public virtual T GetValue()
-		{
-			return value;
-		}
+        public virtual T GetValue()
+        {
+            return value;
+        }
 
-		public override int Size()
-		{
-			return value != null ? 1 : 0;
-		}
+        public override int Size()
+        {
+            return value != null ? 1 : 0;
+        }
 
-		public override bool IsEmpty()
-		{
-			return value == null;
-		}
+        public override bool IsEmpty()
+        {
+            return value == null;
+        }
 
-		public override bool ContainsKey(int key)
-		{
-			return key == this.key && value != null;
-		}
+        public override bool ContainsKey(int key)
+        {
+            return key == this.key && value != null;
+        }
 
-		public override T Get(int key)
-		{
-			if (key == this.key)
-			{
-				return value;
-			}
-			return null;
-		}
+        public override T Get(int key)
+        {
+            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> 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 Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex);
-			}
-			return this;
-		}
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            if (key == this.key && this.value != null)
+            {
+                return new Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex);
+            }
+            return this;
+        }
 
-		public override AbstractEdgeMap<T> Clear()
-		{
-			if (this.value != null)
-			{
-				return new Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex);
-			}
-			return this;
-		}
+        public override AbstractEdgeMap<T> Clear()
+        {
+            if (this.value != null)
+            {
+                return new Antlr4.Runtime.Dfa.SingletonEdgeMap<T>(minIndex, maxIndex);
+            }
+            return this;
+        }
 
-		public override IDictionary<int, T> ToMap()
-		{
-			if (IsEmpty())
-			{
-				return Sharpen.Collections.EmptyMap();
-			}
-			return Sharpen.Collections.SingletonMap(key, value);
-		}
+        public override IDictionary<int, T> ToMap()
+        {
+            if (IsEmpty())
+            {
+                return Sharpen.Collections.EmptyMap();
+            }
+            return Sharpen.Collections.SingletonMap(key, value);
+        }
 
-		public override ICollection<KeyValuePair<int, T>> EntrySet()
-		{
-			return new SingletonEdgeMap.EntrySet(this);
-		}
+        public override ICollection<KeyValuePair<int, T>> EntrySet()
+        {
+            return new SingletonEdgeMap.EntrySet(this);
+        }
 
-		private class EntrySet : AbstractEdgeMap.AbstractEntrySet
-		{
-			public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
-			{
-				return new SingletonEdgeMap.EntryIterator(this);
-			}
+        private class EntrySet : AbstractEdgeMap.AbstractEntrySet
+        {
+            public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+            {
+                return new SingletonEdgeMap.EntryIterator(this);
+            }
 
-			internal EntrySet(SingletonEdgeMap<T> _enclosing) : base(_enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal EntrySet(SingletonEdgeMap<T> _enclosing) : base(_enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly SingletonEdgeMap<T> _enclosing;
-		}
+            private readonly SingletonEdgeMap<T> _enclosing;
+        }
 
-		private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
-		{
-			private int current;
+        private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
+        {
+            private int current;
 
-			public override bool HasNext()
-			{
-				return this.current < this._enclosing.Size();
-			}
+            public override bool HasNext()
+            {
+                return this.current < this._enclosing.Size();
+            }
 
-			public override KeyValuePair<int, T> Next()
-			{
-				if (this.current >= this._enclosing.Size())
-				{
-					throw new NoSuchElementException();
-				}
-				this.current++;
-				return new _KeyValuePair_166(this);
-			}
+            public override KeyValuePair<int, T> Next()
+            {
+                if (this.current >= this._enclosing.Size())
+                {
+                    throw new NoSuchElementException();
+                }
+                this.current++;
+                return new _KeyValuePair_166(this);
+            }
 
-			private sealed class _KeyValuePair_166 : KeyValuePair<int, T>
-			{
-				public _KeyValuePair_166()
-				{
-					this.key = this._enclosing._enclosing._enclosing.key;
-					this.value = this._enclosing._enclosing._enclosing.value;
-				}
+            private sealed class _KeyValuePair_166 : KeyValuePair<int, T>
+            {
+                public _KeyValuePair_166()
+                {
+                    this.key = this._enclosing._enclosing._enclosing.key;
+                    this.value = this._enclosing._enclosing._enclosing.value;
+                }
 
-				private readonly int key;
+                private readonly int key;
 
-				private readonly T value;
+                private readonly T value;
 
-				public int Key
-				{
-					get
-					{
-						return this.key;
-					}
-				}
+                public int Key
+                {
+                    get
+                    {
+                        return this.key;
+                    }
+                }
 
-				public T Value
-				{
-					get
-					{
-						return this.value;
-					}
-				}
+                public T Value
+                {
+                    get
+                    {
+                        return this.value;
+                    }
+                }
 
-				public T SetValue(T value)
-				{
-					throw new NotSupportedException("Not supported yet.");
-				}
-			}
+                public T SetValue(T value)
+                {
+                    throw new NotSupportedException("Not supported yet.");
+                }
+            }
 
-			public override void Remove()
-			{
-				throw new NotSupportedException("Not supported yet.");
-			}
+            public override void Remove()
+            {
+                throw new NotSupportedException("Not supported yet.");
+            }
 
-			internal EntryIterator(SingletonEdgeMap<T> _enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal EntryIterator(SingletonEdgeMap<T> _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly SingletonEdgeMap<T> _enclosing;
-		}
-	}
+            private readonly SingletonEdgeMap<T> _enclosing;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs b/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs
index 022589a14..54582f7e9 100644
--- a/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs
+++ b/Antlr4.Runtime/Dfa/SparseEdgeMap`1.cs
@@ -34,260 +34,260 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Dfa
 {
-	/// <author>Sam Harwell</author>
-	public class SparseEdgeMap<T> : AbstractEdgeMap<T>
-	{
-		private const int DefaultMaxSize = 5;
+    /// <author>Sam Harwell</author>
+    public class SparseEdgeMap<T> : AbstractEdgeMap<T>
+    {
+        private const int DefaultMaxSize = 5;
 
-		private readonly int[] keys;
+        private readonly int[] keys;
 
-		private readonly IList<T> values;
+        private readonly IList<T> values;
 
-		public SparseEdgeMap(int minIndex, int maxIndex) : this(minIndex, maxIndex, DefaultMaxSize
-			)
-		{
-		}
+        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);
-		}
+        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)
-		{
-			if (maxSparseSize < map.values.Count)
-			{
-				throw new ArgumentException();
-			}
-			keys = Arrays.CopyOf(map.keys, maxSparseSize);
-			values = new List<T>(maxSparseSize);
-			Sharpen.Collections.AddAll(values, map.values);
-		}
+        private SparseEdgeMap(Antlr4.Runtime.Dfa.SparseEdgeMap<T> map, int maxSparseSize)
+             : base(map.minIndex, map.maxIndex)
+        {
+            if (maxSparseSize < map.values.Count)
+            {
+                throw new ArgumentException();
+            }
+            keys = Arrays.CopyOf(map.keys, maxSparseSize);
+            values = new List<T>(maxSparseSize);
+            Sharpen.Collections.AddAll(values, map.values);
+        }
 
-		public virtual int[] GetKeys()
-		{
-			return keys;
-		}
+        public virtual int[] GetKeys()
+        {
+            return keys;
+        }
 
-		public virtual IList<T> GetValues()
-		{
-			return values;
-		}
+        public virtual IList<T> GetValues()
+        {
+            return values;
+        }
 
-		public virtual int GetMaxSparseSize()
-		{
-			return keys.Length;
-		}
+        public virtual int GetMaxSparseSize()
+        {
+            return keys.Length;
+        }
 
-		public override int Size()
-		{
-			return values.Count;
-		}
+        public override int Size()
+        {
+            return values.Count;
+        }
 
-		public override bool IsEmpty()
-		{
-			return values.IsEmpty();
-		}
+        public override bool IsEmpty()
+        {
+            return values.IsEmpty();
+        }
 
-		public override bool ContainsKey(int key)
-		{
-			return Get(key) != null;
-		}
+        public override bool ContainsKey(int key)
+        {
+            return Get(key) != null;
+        }
 
-		public override T Get(int key)
-		{
-			int index = System.Array.BinarySearch(keys, 0, Size(), key);
-			if (index < 0)
-			{
-				return null;
-			}
-			return values[index];
-		}
+        public override T Get(int key)
+        {
+            int index = System.Array.BinarySearch(keys, 0, Size(), 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 ((Antlr4.Runtime.Dfa.SparseEdgeMap<T>)Remove(key));
-			}
-			lock (values)
-			{
-				int index = System.Array.BinarySearch(keys, 0, Size(), key);
-				if (index >= 0)
-				{
-					// replace existing entry
-					values.Set(index, value);
-					return this;
-				}
-				System.Diagnostics.Debug.Assert(index < 0 && value != null);
-				int insertIndex = -index - 1;
-				if (Size() < GetMaxSparseSize() && insertIndex == Size())
-				{
-					// stay sparse and add new entry
-					keys[insertIndex] = key;
-					values.AddItem(value);
-					return this;
-				}
-				int desiredSize = Size() >= GetMaxSparseSize() ? GetMaxSparseSize() * 2 : GetMaxSparseSize
-					();
-				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, resized
-						.keys.Length - insertIndex - 1);
-					resized.keys[insertIndex] = key;
-					resized.values.Add(insertIndex, value);
-					return resized;
-				}
-			}
-		}
+        public override AbstractEdgeMap<T> Put(int key, T value)
+        {
+            if (key < minIndex || key > maxIndex)
+            {
+                return this;
+            }
+            if (value == null)
+            {
+                return ((Antlr4.Runtime.Dfa.SparseEdgeMap<T>)Remove(key));
+            }
+            lock (values)
+            {
+                int index = System.Array.BinarySearch(keys, 0, Size(), key);
+                if (index >= 0)
+                {
+                    // replace existing entry
+                    values.Set(index, value);
+                    return this;
+                }
+                System.Diagnostics.Debug.Assert(index < 0 && value != null);
+                int insertIndex = -index - 1;
+                if (Size() < GetMaxSparseSize() && insertIndex == Size())
+                {
+                    // stay sparse and add new entry
+                    keys[insertIndex] = key;
+                    values.AddItem(value);
+                    return this;
+                }
+                int desiredSize = Size() >= GetMaxSparseSize() ? GetMaxSparseSize() * 2 : GetMaxSparseSize
+                    ();
+                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, resized
+                        .keys.Length - insertIndex - 1);
+                    resized.keys[insertIndex] = key;
+                    resized.values.Add(insertIndex, value);
+                    return resized;
+                }
+            }
+        }
 
-		public override AbstractEdgeMap<T> Remove(int key)
-		{
-			int index = System.Array.BinarySearch(keys, 0, Size(), key);
-			if (index < 0)
-			{
-				return this;
-			}
-			if (index == values.Count - 1)
-			{
-				values.Remove(index);
-				return this;
-			}
-			Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap
-				<T>(this, GetMaxSparseSize());
-			System.Array.Copy(result.keys, index + 1, result.keys, index, Size() - index - 1);
-			result.values.Remove(index);
-			return result;
-		}
+        public override AbstractEdgeMap<T> Remove(int key)
+        {
+            int index = System.Array.BinarySearch(keys, 0, Size(), key);
+            if (index < 0)
+            {
+                return this;
+            }
+            if (index == values.Count - 1)
+            {
+                values.Remove(index);
+                return this;
+            }
+            Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap
+                <T>(this, GetMaxSparseSize());
+            System.Array.Copy(result.keys, index + 1, result.keys, index, Size() - index - 1);
+            result.values.Remove(index);
+            return result;
+        }
 
-		public override AbstractEdgeMap<T> Clear()
-		{
-			if (IsEmpty())
-			{
-				return this;
-			}
-			Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap
-				<T>(this, GetMaxSparseSize());
-			result.values.Clear();
-			return result;
-		}
+        public override AbstractEdgeMap<T> Clear()
+        {
+            if (IsEmpty())
+            {
+                return this;
+            }
+            Antlr4.Runtime.Dfa.SparseEdgeMap<T> result = new Antlr4.Runtime.Dfa.SparseEdgeMap
+                <T>(this, GetMaxSparseSize());
+            result.values.Clear();
+            return result;
+        }
 
-		public override IDictionary<int, T> ToMap()
-		{
-			if (IsEmpty())
-			{
-				return Sharpen.Collections.EmptyMap();
-			}
-			IDictionary<int, T> result = new LinkedHashMap<int, T>();
-			for (int i = 0; i < Size(); i++)
-			{
-				result.Put(keys[i], values[i]);
-			}
-			return result;
-		}
+        public override IDictionary<int, T> ToMap()
+        {
+            if (IsEmpty())
+            {
+                return Sharpen.Collections.EmptyMap();
+            }
+            IDictionary<int, T> result = new LinkedHashMap<int, T>();
+            for (int i = 0; i < Size(); i++)
+            {
+                result.Put(keys[i], values[i]);
+            }
+            return result;
+        }
 
-		public override ICollection<KeyValuePair<int, T>> EntrySet()
-		{
-			return new SparseEdgeMap.EntrySet(this);
-		}
+        public override ICollection<KeyValuePair<int, T>> EntrySet()
+        {
+            return new SparseEdgeMap.EntrySet(this);
+        }
 
-		private class EntrySet : AbstractEdgeMap.AbstractEntrySet
-		{
-			public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
-			{
-				return new SparseEdgeMap.EntryIterator(this);
-			}
+        private class EntrySet : AbstractEdgeMap.AbstractEntrySet
+        {
+            public override IEnumerator<KeyValuePair<int, T>> GetEnumerator()
+            {
+                return new SparseEdgeMap.EntryIterator(this);
+            }
 
-			internal EntrySet(SparseEdgeMap<T> _enclosing) : base(_enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal EntrySet(SparseEdgeMap<T> _enclosing) : base(_enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly SparseEdgeMap<T> _enclosing;
-		}
+            private readonly SparseEdgeMap<T> _enclosing;
+        }
 
-		private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
-		{
-			private int current;
+        private class EntryIterator : IEnumerator<KeyValuePair<int, T>>
+        {
+            private int current;
 
-			public override bool HasNext()
-			{
-				return this.current < this._enclosing.Size();
-			}
+            public override bool HasNext()
+            {
+                return this.current < this._enclosing.Size();
+            }
 
-			public override KeyValuePair<int, T> Next()
-			{
-				if (this.current >= this._enclosing.Size())
-				{
-					throw new NoSuchElementException();
-				}
-				this.current++;
-				return new _KeyValuePair_226(this);
-			}
+            public override KeyValuePair<int, T> Next()
+            {
+                if (this.current >= this._enclosing.Size())
+                {
+                    throw new NoSuchElementException();
+                }
+                this.current++;
+                return new _KeyValuePair_226(this);
+            }
 
-			private sealed class _KeyValuePair_226 : KeyValuePair<int, T>
-			{
-				public _KeyValuePair_226()
-				{
-					this.key = this._enclosing._enclosing.keys[this._enclosing.current - 1];
-					this.value = this._enclosing._enclosing.values[this._enclosing.current - 1];
-				}
+            private sealed class _KeyValuePair_226 : KeyValuePair<int, T>
+            {
+                public _KeyValuePair_226()
+                {
+                    this.key = this._enclosing._enclosing.keys[this._enclosing.current - 1];
+                    this.value = this._enclosing._enclosing.values[this._enclosing.current - 1];
+                }
 
-				private readonly int key;
+                private readonly int key;
 
-				private readonly T value;
+                private readonly T value;
 
-				public int Key
-				{
-					get
-					{
-						return this.key;
-					}
-				}
+                public int Key
+                {
+                    get
+                    {
+                        return this.key;
+                    }
+                }
 
-				public T Value
-				{
-					get
-					{
-						return this.value;
-					}
-				}
+                public T Value
+                {
+                    get
+                    {
+                        return this.value;
+                    }
+                }
 
-				public T SetValue(T value)
-				{
-					throw new NotSupportedException("Not supported yet.");
-				}
-			}
+                public T SetValue(T value)
+                {
+                    throw new NotSupportedException("Not supported yet.");
+                }
+            }
 
-			public override void Remove()
-			{
-				throw new NotSupportedException("Not supported yet.");
-			}
+            public override void Remove()
+            {
+                throw new NotSupportedException("Not supported yet.");
+            }
 
-			internal EntryIterator(SparseEdgeMap<T> _enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
+            internal EntryIterator(SparseEdgeMap<T> _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
 
-			private readonly SparseEdgeMap<T> _enclosing;
-		}
-	}
+            private readonly SparseEdgeMap<T> _enclosing;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/DiagnosticErrorListener.cs b/Antlr4.Runtime/DiagnosticErrorListener.cs
index 3382c220b..72799378c 100644
--- a/Antlr4.Runtime/DiagnosticErrorListener.cs
+++ b/Antlr4.Runtime/DiagnosticErrorListener.cs
@@ -35,39 +35,39 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public class DiagnosticErrorListener : BaseErrorListener
-	{
-		public override void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, 
-			int stopIndex, BitSet ambigAlts, ATNConfigSet configs)
-		{
-			string format = "reportAmbiguity d=%s: ambigAlts=%s, input='%s'";
-			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
-				, dfa.decision), ambigAlts, ((ITokenStream)recognizer.GetInputStream()).GetText(
-				Interval.Of(startIndex, stopIndex))));
-		}
+    public class DiagnosticErrorListener : BaseErrorListener
+    {
+        public override void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, 
+            int stopIndex, BitSet ambigAlts, ATNConfigSet configs)
+        {
+            string format = "reportAmbiguity d=%s: ambigAlts=%s, input='%s'";
+            recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
+                , dfa.decision), ambigAlts, ((ITokenStream)recognizer.GetInputStream()).GetText
+                (Interval.Of(startIndex, stopIndex))));
+        }
 
-		public override void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int 
-			startIndex, int stopIndex, SimulatorState initialState)
-		{
-			string format = "reportAttemptingFullContext d=%s, input='%s'";
-			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
-				, dfa.decision), ((ITokenStream)recognizer.GetInputStream()).GetText(Interval.Of
-				(startIndex, stopIndex))));
-		}
+        public override void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int 
+            startIndex, int stopIndex, SimulatorState initialState)
+        {
+            string format = "reportAttemptingFullContext d=%s, input='%s'";
+            recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
+                , dfa.decision), ((ITokenStream)recognizer.GetInputStream()).GetText(Interval
+                .Of(startIndex, stopIndex))));
+        }
 
-		public override void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
-			, int stopIndex, SimulatorState acceptState)
-		{
-			string format = "reportContextSensitivity d=%s, input='%s'";
-			recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
-				, dfa.decision), ((ITokenStream)recognizer.GetInputStream()).GetText(Interval.Of
-				(startIndex, stopIndex))));
-		}
+        public override void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
+            , int stopIndex, SimulatorState acceptState)
+        {
+            string format = "reportContextSensitivity d=%s, input='%s'";
+            recognizer.NotifyErrorListeners(string.Format(format, GetDecisionDescription(recognizer
+                , dfa.decision), ((ITokenStream)recognizer.GetInputStream()).GetText(Interval
+                .Of(startIndex, stopIndex))));
+        }
 
-		protected internal virtual string GetDecisionDescription(Parser recognizer, int decision
-			)
-		{
-			return Sharpen.Extensions.ToString(decision);
-		}
-	}
+        protected internal virtual string GetDecisionDescription(Parser recognizer, int decision
+            )
+        {
+            return Sharpen.Extensions.ToString(decision);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/FailedPredicateException.cs b/Antlr4.Runtime/FailedPredicateException.cs
index 2c015d5a8..9c9c19a3e 100644
--- a/Antlr4.Runtime/FailedPredicateException.cs
+++ b/Antlr4.Runtime/FailedPredicateException.cs
@@ -34,77 +34,77 @@ using 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;
+    /// <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 ruleIndex;
 
-		private readonly int predicateIndex;
+        private readonly int predicateIndex;
 
-		private readonly string predicate;
+        private readonly string predicate;
 
-		public FailedPredicateException(Parser recognizer) : this(recognizer, null)
-		{
-		}
+        public FailedPredicateException(Parser recognizer) : this(recognizer, null)
+        {
+        }
 
-		public FailedPredicateException(Parser recognizer, string predicate) : this(recognizer
-			, predicate, 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
-			.GetInputStream()), recognizer._ctx)
-		{
-			ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
-			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.SetOffendingToken(recognizer.GetCurrentToken());
-		}
+        public FailedPredicateException(Parser recognizer, string predicate, string message
+            ) : base(FormatMessage(predicate, message), recognizer, ((ITokenStream)recognizer
+            .GetInputStream()), recognizer._ctx)
+        {
+            ATNState s = recognizer.GetInterpreter().atn.states[recognizer.GetState()];
+            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.SetOffendingToken(recognizer.GetCurrentToken());
+        }
 
-		public virtual int GetRuleIndex()
-		{
-			return ruleIndex;
-		}
+        public virtual int GetRuleIndex()
+        {
+            return ruleIndex;
+        }
 
-		public virtual int GetPredIndex()
-		{
-			return predicateIndex;
-		}
+        public virtual int GetPredIndex()
+        {
+            return predicateIndex;
+        }
 
-		[Nullable]
-		public virtual string GetPredicate()
-		{
-			return predicate;
-		}
+        [Nullable]
+        public virtual string GetPredicate()
+        {
+            return predicate;
+        }
 
-		[NotNull]
-		private static string FormatMessage(string predicate, string message)
-		{
-			if (message != null)
-			{
-				return message;
-			}
-			return string.Format("failed predicate: {%s}?", predicate);
-		}
-	}
+        [NotNull]
+        private static string FormatMessage(string predicate, string message)
+        {
+            if (message != null)
+            {
+                return message;
+            }
+            return string.Format("failed predicate: {%s}?", predicate);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/IAntlrErrorListener`1.cs b/Antlr4.Runtime/IAntlrErrorListener`1.cs
index 414ec4d18..f662db84d 100644
--- a/Antlr4.Runtime/IAntlrErrorListener`1.cs
+++ b/Antlr4.Runtime/IAntlrErrorListener`1.cs
@@ -32,47 +32,47 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>How to emit recognition errors</summary>
-	public interface IAntlrErrorListener<Symbol>
-	{
-		/// <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. The
-		/// parser ANTLRErrorStrategy 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.
-		/// The 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).
-		/// </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, e has token at which we
-		/// started production for the decision.
-		/// </param>
-		/// <param name="line">
-		/// At what line in input to the error occur? This always refers to
-		/// stopTokenIndex
-		/// </param>
-		/// <param name="charPositionInLine">At what character position within that line did the error occur.
-		/// 	</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<T>(Recognizer<T, object> recognizer, T offendingSymbol, int line
-			, int charPositionInLine, string msg, RecognitionException e) where T:Symbol;
-	}
+    /// <summary>How to emit recognition errors</summary>
+    public interface IAntlrErrorListener<Symbol>
+    {
+        /// <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. The
+        /// parser ANTLRErrorStrategy 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.
+        /// The 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).
+        /// </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, e has token at which we
+        /// started production for the decision.
+        /// </param>
+        /// <param name="line">
+        /// At what line in input to the error occur? This always refers to
+        /// stopTokenIndex
+        /// </param>
+        /// <param name="charPositionInLine">At what character position within that line did the error occur.
+        ///     </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<T>(Recognizer<T, object> recognizer, T offendingSymbol, int line
+            , int charPositionInLine, string msg, RecognitionException e) where T:Symbol;
+    }
 }
diff --git a/Antlr4.Runtime/IAntlrErrorStrategy.cs b/Antlr4.Runtime/IAntlrErrorStrategy.cs
index a8a9bd140..d387f95d8 100644
--- a/Antlr4.Runtime/IAntlrErrorStrategy.cs
+++ b/Antlr4.Runtime/IAntlrErrorStrategy.cs
@@ -32,126 +32,126 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// The interface for defining strategies to deal with syntax errors
-	/// encountered during a parse by ANTLR-generated parsers and tree parsers.
-	/// </summary>
-	/// <remarks>
-	/// The interface for defining strategies to deal with syntax errors
-	/// encountered during a parse by ANTLR-generated parsers and tree parsers.
-	/// We distinguish between three different kinds of errors:
-	/// o The parser could not figure out which path to take in the ATN
-	/// (none of the available alternatives could possibly match)
-	/// o The current input does not match what we were looking for.
-	/// o A predicate evaluated to false.
-	/// The default implementation of this interface reports errors to any
-	/// error listeners of the parser. It also handles single token insertion
-	/// and deletion for mismatched elements.
-	/// We pass in the parser to each function so that the same strategy
-	/// can be shared between multiple parsers running at the same time.
-	/// This is just for flexibility, not that we need it for the default system.
-	/// TODO: To bail out upon first error, simply rethrow e?
-	/// TODO: what to do about lexers
-	/// </remarks>
-	public interface IAntlrErrorStrategy
-	{
-		/// <summary>
-		/// When matching elements within alternative, use this method
-		/// to recover.
-		/// </summary>
-		/// <remarks>
-		/// When matching elements within alternative, use this method
-		/// to recover. The default implementation uses single token
-		/// insertion and deletion. If you want to change the way ANTLR
-		/// response to mismatched element errors within an alternative,
-		/// implement this method.
-		/// From the recognizer, we can get the input stream to get
-		/// the current input symbol and we can get the current context.
-		/// That context gives us the current state within the ATN.
-		/// From that state, we can look at its transition to figure out
-		/// what was expected.
-		/// Because we can recover from a single token deletions by
-		/// "inserting" tokens, we need to specify what that implicitly created
-		/// token is. We use object, because it could be a tree node.
-		/// </remarks>
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		IToken RecoverInline(Parser recognizer);
+    /// <summary>
+    /// The interface for defining strategies to deal with syntax errors
+    /// encountered during a parse by ANTLR-generated parsers and tree parsers.
+    /// </summary>
+    /// <remarks>
+    /// The interface for defining strategies to deal with syntax errors
+    /// encountered during a parse by ANTLR-generated parsers and tree parsers.
+    /// We distinguish between three different kinds of errors:
+    /// o The parser could not figure out which path to take in the ATN
+    /// (none of the available alternatives could possibly match)
+    /// o The current input does not match what we were looking for.
+    /// o A predicate evaluated to false.
+    /// The default implementation of this interface reports errors to any
+    /// error listeners of the parser. It also handles single token insertion
+    /// and deletion for mismatched elements.
+    /// We pass in the parser to each function so that the same strategy
+    /// can be shared between multiple parsers running at the same time.
+    /// This is just for flexibility, not that we need it for the default system.
+    /// TODO: To bail out upon first error, simply rethrow e?
+    /// TODO: what to do about lexers
+    /// </remarks>
+    public interface IAntlrErrorStrategy
+    {
+        /// <summary>
+        /// When matching elements within alternative, use this method
+        /// to recover.
+        /// </summary>
+        /// <remarks>
+        /// When matching elements within alternative, use this method
+        /// to recover. The default implementation uses single token
+        /// insertion and deletion. If you want to change the way ANTLR
+        /// response to mismatched element errors within an alternative,
+        /// implement this method.
+        /// From the recognizer, we can get the input stream to get
+        /// the current input symbol and we can get the current context.
+        /// That context gives us the current state within the ATN.
+        /// From that state, we can look at its transition to figure out
+        /// what was expected.
+        /// Because we can recover from a single token deletions by
+        /// "inserting" tokens, we need to specify what that implicitly created
+        /// token is. We use object, because it could be a tree node.
+        /// </remarks>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        IToken RecoverInline(Parser recognizer);
 
-		/// <summary>
-		/// Resynchronize the parser by consuming tokens until we find one
-		/// in the resynchronization set--loosely the set of tokens that can follow
-		/// the current rule.
-		/// </summary>
-		/// <remarks>
-		/// Resynchronize the parser by consuming tokens until we find one
-		/// in the resynchronization set--loosely the set of tokens that can follow
-		/// the current rule. The exception contains info you might want to
-		/// use to recover better.
-		/// </remarks>
-		void Recover(Parser recognizer, RecognitionException e);
+        /// <summary>
+        /// Resynchronize the parser by consuming tokens until we find one
+        /// in the resynchronization set--loosely the set of tokens that can follow
+        /// the current rule.
+        /// </summary>
+        /// <remarks>
+        /// Resynchronize the parser by consuming tokens until we find one
+        /// in the resynchronization set--loosely the set of tokens that can follow
+        /// the current rule. The exception contains info you might want to
+        /// use to recover better.
+        /// </remarks>
+        void Recover(Parser recognizer, RecognitionException e);
 
-		/// <summary>
-		/// Make sure that the current lookahead symbol is consistent with
-		/// what were expecting at this point in the ATN.
-		/// </summary>
-		/// <remarks>
-		/// Make 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.
-		/// Implements Jim Idle's magic sync mechanism in closures and optional
-		/// subrules. E.g.,
-		/// a : sync ( stuff sync )* ;
-		/// sync : {consume to what can follow sync} ;
-		/// 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
-		/// classDef : 'class' ID '{' member* '}'
-		/// 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.
-		/// 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 { }.
-		/// </remarks>
-		void Sync(Parser recognizer);
+        /// <summary>
+        /// Make sure that the current lookahead symbol is consistent with
+        /// what were expecting at this point in the ATN.
+        /// </summary>
+        /// <remarks>
+        /// Make 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.
+        /// Implements Jim Idle's magic sync mechanism in closures and optional
+        /// subrules. E.g.,
+        /// a : sync ( stuff sync )* ;
+        /// sync : {consume to what can follow sync} ;
+        /// 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
+        /// classDef : 'class' ID '{' member* '}'
+        /// 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.
+        /// 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 { }.
+        /// </remarks>
+        void Sync(Parser recognizer);
 
-		/// <summary>Notify handler that parser has entered an error state.</summary>
-		/// <remarks>
-		/// Notify handler that parser has entered an error state.  The
-		/// parser currently doesn't call this--the handler itself calls this
-		/// in report error methods.  But, for symmetry with endErrorCondition,
-		/// this method is in the interface.
-		/// </remarks>
-		void BeginErrorCondition(Parser recognizer);
+        /// <summary>Notify handler that parser has entered an error state.</summary>
+        /// <remarks>
+        /// Notify handler that parser has entered an error state.  The
+        /// parser currently doesn't call this--the handler itself calls this
+        /// in report error methods.  But, for symmetry with endErrorCondition,
+        /// this method is in the interface.
+        /// </remarks>
+        void BeginErrorCondition(Parser recognizer);
 
-		/// <summary>
-		/// Is the parser in the process of recovering from an error? Upon
-		/// a syntax error, the parser enters recovery mode and stays there until
-		/// the next successful match of a token.
-		/// </summary>
-		/// <remarks>
-		/// Is the parser in the process of recovering from an error? Upon
-		/// a syntax error, the parser enters recovery mode and stays there until
-		/// the next successful match of a token. In this way, we can
-		/// avoid sending out spurious error messages. We only want one error
-		/// message per syntax error
-		/// </remarks>
-		bool InErrorRecoveryMode(Parser recognizer);
+        /// <summary>
+        /// Is the parser in the process of recovering from an error? Upon
+        /// a syntax error, the parser enters recovery mode and stays there until
+        /// the next successful match of a token.
+        /// </summary>
+        /// <remarks>
+        /// Is the parser in the process of recovering from an error? Upon
+        /// a syntax error, the parser enters recovery mode and stays there until
+        /// the next successful match of a token. In this way, we can
+        /// avoid sending out spurious error messages. We only want one error
+        /// message per syntax error
+        /// </remarks>
+        bool InErrorRecoveryMode(Parser recognizer);
 
-		/// <summary>Reset the error handler.</summary>
-		/// <remarks>
-		/// Reset the error handler. Call this when the parser
-		/// matches a valid token (indicating no longer in recovery mode)
-		/// and from its own reset method.
-		/// </remarks>
-		void EndErrorCondition(Parser recognizer);
+        /// <summary>Reset the error handler.</summary>
+        /// <remarks>
+        /// Reset the error handler. Call this when the parser
+        /// matches a valid token (indicating no longer in recovery mode)
+        /// and from its own reset method.
+        /// </remarks>
+        void EndErrorCondition(Parser recognizer);
 
-		/// <summary>Report any kind of RecognitionException.</summary>
-		/// <remarks>Report any kind of RecognitionException.</remarks>
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		void ReportError(Parser recognizer, RecognitionException e);
-	}
+        /// <summary>Report any kind of RecognitionException.</summary>
+        /// <remarks>Report any kind of RecognitionException.</remarks>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        void ReportError(Parser recognizer, RecognitionException e);
+    }
 }
diff --git a/Antlr4.Runtime/ICharStream.cs b/Antlr4.Runtime/ICharStream.cs
index 58925ab91..26fde60cb 100644
--- a/Antlr4.Runtime/ICharStream.cs
+++ b/Antlr4.Runtime/ICharStream.cs
@@ -33,80 +33,80 @@ using 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 abstract class ICharStream : IIntStream
-	{
-		/// <summary>
-		/// The minimum allowed value for a character in a
-		/// <code>CharStream</code>
-		/// .
-		/// </summary>
-		public const int MinChar = char.MinValue;
+    /// <summary>A source of characters for an ANTLR lexer.</summary>
+    /// <remarks>A source of characters for an ANTLR lexer.</remarks>
+    public abstract class ICharStream : IIntStream
+    {
+        /// <summary>
+        /// The minimum allowed value for a character in a
+        /// <code>CharStream</code>
+        /// .
+        /// </summary>
+        public const int MinChar = char.MinValue;
 
-		/// <summary>
-		/// The maximum allowed value for a character in a
-		/// <code>CharStream</code>
-		/// .
-		/// <p/>
-		/// This value is
-		/// <code>Character.MAX_VALUE - 1</code>
-		/// , which reserves the value
-		/// <code>Character.MAX_VALUE</code>
-		/// for special use within an implementing class.
-		/// For some implementations, the data buffers required for supporting the
-		/// marked ranges of
-		/// <see cref="IIntStream">IIntStream</see>
-		/// are stored as
-		/// <code>char[]</code>
-		/// instead
-		/// of
-		/// <code>int[]</code>
-		/// , with
-		/// <code>Character.MAX_VALUE</code>
-		/// being used instead of
-		/// <code>-1</code>
-		/// to mark the end of the stream internally.
-		/// </summary>
-		public const int MaxChar = char.MaxValue - 1;
+        /// <summary>
+        /// The maximum allowed value for a character in a
+        /// <code>CharStream</code>
+        /// .
+        /// <p/>
+        /// This value is
+        /// <code>Character.MAX_VALUE - 1</code>
+        /// , which reserves the value
+        /// <code>Character.MAX_VALUE</code>
+        /// for special use within an implementing class.
+        /// For some implementations, the data buffers required for supporting the
+        /// marked ranges of
+        /// <see cref="IIntStream">IIntStream</see>
+        /// are stored as
+        /// <code>char[]</code>
+        /// instead
+        /// of
+        /// <code>int[]</code>
+        /// , with
+        /// <code>Character.MAX_VALUE</code>
+        /// being used instead of
+        /// <code>-1</code>
+        /// to mark the end of the stream internally.
+        /// </summary>
+        public const int MaxChar = char.MaxValue - 1;
 
-		/// <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
-		/// <code>interval</code>
-		/// lies entirely within a marked range. For more
-		/// information about marked ranges, see
-		/// <see cref="IIntStream.Mark()">IIntStream.Mark()</see>
-		/// .
-		/// </remarks>
-		/// <param name="interval">an interval within the stream</param>
-		/// <returns>the text of the specified interval</returns>
-		/// <exception cref="System.ArgumentNullException">
-		/// if
-		/// <code>interval</code>
-		/// is
-		/// <code>null</code>
-		/// </exception>
-		/// <exception cref="System.ArgumentException">
-		/// if
-		/// <code>interval.a &lt; 0</code>
-		/// , or if
-		/// <code>interval.b &lt; interval.a - 1</code>
-		/// , or if
-		/// <code>interval.b</code>
-		/// 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>
-		[NotNull]
-		public abstract string GetText(Interval interval);
-	}
+        /// <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
+        /// <code>interval</code>
+        /// lies entirely within a marked range. For more
+        /// information about marked ranges, see
+        /// <see cref="IIntStream.Mark()">IIntStream.Mark()</see>
+        /// .
+        /// </remarks>
+        /// <param name="interval">an interval within the stream</param>
+        /// <returns>the text of the specified interval</returns>
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <code>interval</code>
+        /// is
+        /// <code>null</code>
+        /// </exception>
+        /// <exception cref="System.ArgumentException">
+        /// if
+        /// <code>interval.a &lt; 0</code>
+        /// , or if
+        /// <code>interval.b &lt; interval.a - 1</code>
+        /// , or if
+        /// <code>interval.b</code>
+        /// 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>
+        [NotNull]
+        public abstract string GetText(Interval interval);
+    }
 }
diff --git a/Antlr4.Runtime/IIntStream.cs b/Antlr4.Runtime/IIntStream.cs
index a288192bc..d7526419c 100644
--- a/Antlr4.Runtime/IIntStream.cs
+++ b/Antlr4.Runtime/IIntStream.cs
@@ -32,338 +32,338 @@ using 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()">Mark()</see>
-	/// .
-	/// <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:
-	/// <ul>
-	/// <li>
-	/// <see cref="La(int)">La(int)</see>
-	/// </li>
-	/// <li>
-	/// <see cref="Consume()">Consume()</see>
-	/// </li>
-	/// <li>
-	/// <see cref="Size()">Size()</see>
-	/// </li>
-	/// </ul>
-	/// </remarks>
-	public abstract class IIntStream
-	{
-		/// <summary>
-		/// The value returned by
-		/// <see cref="La(int)">LA()</see>
-		/// when the end of the stream is
-		/// reached.
-		/// </summary>
-		public const int Eof = -1;
+    /// <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()">Mark()</see>
+    /// .
+    /// <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:
+    /// <ul>
+    /// <li>
+    /// <see cref="La(int)">La(int)</see>
+    /// </li>
+    /// <li>
+    /// <see cref="Consume()">Consume()</see>
+    /// </li>
+    /// <li>
+    /// <see cref="Size()">Size()</see>
+    /// </li>
+    /// </ul>
+    /// </remarks>
+    public abstract class IIntStream
+    {
+        /// <summary>
+        /// The value returned by
+        /// <see cref="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="SourceName()">SourceName()</see>
-		/// when the actual name of the
-		/// underlying source is not known.
-		/// </summary>
-		public const string UnknownSourceName = "<unknown>";
+        /// <summary>
+        /// The value returned by
+        /// <see cref="SourceName()">SourceName()</see>
+        /// when the actual name of the
+        /// underlying source is not known.
+        /// </summary>
+        public const string UnknownSourceName = "<unknown>";
 
-		/// <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
-		/// <code>index()</code>
-		/// after calling this method.</li>
-		/// <li><strong>Ordered lookahead:</strong> The value of
-		/// <code>LA(1)</code>
-		/// before
-		/// calling this method becomes the value of
-		/// <code>LA(-1)</code>
-		/// after calling
-		/// this method.</li>
-		/// </ul>
-		/// Note that calling this method does not guarantee that
-		/// <code>index()</code>
-		/// is
-		/// incremented by exactly 1, as that would preclude the ability to implement
-		/// filtering streams (e.g.
-		/// <see cref="CommonTokenStream">CommonTokenStream</see>
-		/// 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
-		/// <code>LA(1)==</code>
-		/// <see cref="Eof">EOF</see>
-		/// before calling
-		/// <code>consume</code>
-		/// ).
-		/// </exception>
-		public abstract void Consume();
+        /// <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
+        /// <code>index()</code>
+        /// after calling this method.</li>
+        /// <li><strong>Ordered lookahead:</strong> The value of
+        /// <code>LA(1)</code>
+        /// before
+        /// calling this method becomes the value of
+        /// <code>LA(-1)</code>
+        /// after calling
+        /// this method.</li>
+        /// </ul>
+        /// Note that calling this method does not guarantee that
+        /// <code>index()</code>
+        /// is
+        /// incremented by exactly 1, as that would preclude the ability to implement
+        /// filtering streams (e.g.
+        /// <see cref="CommonTokenStream">CommonTokenStream</see>
+        /// 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
+        /// <code>LA(1)==</code>
+        /// <see cref="Eof">EOF</see>
+        /// before calling
+        /// <code>consume</code>
+        /// ).
+        /// </exception>
+        public abstract void Consume();
 
-		/// <summary>
-		/// Gets the value of the symbol at offset
-		/// <code>i</code>
-		/// from the current
-		/// position. When
-		/// <code>i==1</code>
-		/// , this method returns the value of the current
-		/// symbol in the stream (which is the next symbol to be consumed). When
-		/// <code>i==-1</code>
-		/// , this method returns the value of the previously read
-		/// symbol in the stream. It is not valid to call this method with
-		/// <code>i==0</code>
-		/// , 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:
-		/// <ul>
-		/// <li>
-		/// <code>i&gt;0</code>
-		/// </li>
-		/// <li>
-		/// <code>i==-1</code>
-		/// and
-		/// <see cref="Index()">index()</see>
-		/// returns a value greater
-		/// than the value of
-		/// <code>index()</code>
-		/// after the stream was constructed
-		/// and
-		/// <code>LA(1)</code>
-		/// was called in that order. Specifying the current
-		/// <code>index()</code>
-		/// 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
-		/// <code>LA(1)</code>
-		/// allows for lazily initialized streams.</li>
-		/// <li>
-		/// <code>LA(i)</code>
-		/// refers to a symbol consumed within a marked region
-		/// that has not yet been released.</li>
-		/// </ul>
-		/// If
-		/// <code>i</code>
-		/// represents a position at or beyond the end of the stream,
-		/// this method returns
-		/// <see cref="Eof">Eof</see>
-		/// .
-		/// <p/>
-		/// The return value is unspecified if
-		/// <code>i&lt;0</code>
-		/// and fewer than
-		/// <code>-i</code>
-		/// calls to
-		/// <see cref="Consume()">consume()</see>
-		/// have occurred from the beginning of
-		/// the stream before calling this method.
-		/// </summary>
-		/// <exception cref="System.NotSupportedException">
-		/// if the stream does not support
-		/// retrieving the value of the specified symbol
-		/// </exception>
-		public abstract int La(int i);
+        /// <summary>
+        /// Gets the value of the symbol at offset
+        /// <code>i</code>
+        /// from the current
+        /// position. When
+        /// <code>i==1</code>
+        /// , this method returns the value of the current
+        /// symbol in the stream (which is the next symbol to be consumed). When
+        /// <code>i==-1</code>
+        /// , this method returns the value of the previously read
+        /// symbol in the stream. It is not valid to call this method with
+        /// <code>i==0</code>
+        /// , 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:
+        /// <ul>
+        /// <li>
+        /// <code>i&gt;0</code>
+        /// </li>
+        /// <li>
+        /// <code>i==-1</code>
+        /// and
+        /// <see cref="Index()">index()</see>
+        /// returns a value greater
+        /// than the value of
+        /// <code>index()</code>
+        /// after the stream was constructed
+        /// and
+        /// <code>LA(1)</code>
+        /// was called in that order. Specifying the current
+        /// <code>index()</code>
+        /// 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
+        /// <code>LA(1)</code>
+        /// allows for lazily initialized streams.</li>
+        /// <li>
+        /// <code>LA(i)</code>
+        /// refers to a symbol consumed within a marked region
+        /// that has not yet been released.</li>
+        /// </ul>
+        /// If
+        /// <code>i</code>
+        /// represents a position at or beyond the end of the stream,
+        /// this method returns
+        /// <see cref="Eof">Eof</see>
+        /// .
+        /// <p/>
+        /// The return value is unspecified if
+        /// <code>i&lt;0</code>
+        /// and fewer than
+        /// <code>-i</code>
+        /// calls to
+        /// <see cref="Consume()">consume()</see>
+        /// have occurred from the beginning of
+        /// the stream before calling this method.
+        /// </summary>
+        /// <exception cref="System.NotSupportedException">
+        /// if the stream does not support
+        /// retrieving the value of the specified symbol
+        /// </exception>
+        public abstract 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
-		/// <code>mark()</code>
-		/// 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
-		/// <code>int</code>
-		/// ) 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
-		/// <code>mark()</code>
-		/// /
-		/// <code>release()</code>
-		/// 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/>
-		/// 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/>
-		/// This method does not change the current position in the input stream.
-		/// <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.
-		/// <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>
-		public abstract int Mark();
+        /// <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
+        /// <code>mark()</code>
+        /// 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
+        /// <code>int</code>
+        /// ) 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
+        /// <code>mark()</code>
+        /// /
+        /// <code>release()</code>
+        /// 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/>
+        /// 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/>
+        /// This method does not change the current position in the input stream.
+        /// <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.
+        /// <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>
+        public abstract int Mark();
 
-		/// <summary>
-		/// This method releases a marked range created by a call to
-		/// <see cref="Mark()">mark()</see>
-		/// . Calls to
-		/// <code>release()</code>
-		/// must appear in the
-		/// reverse order of the corresponding calls to
-		/// <code>mark()</code>
-		/// . If a mark is
-		/// released twice, or if marks are not released in reverse order of the
-		/// corresponding calls to
-		/// <code>mark()</code>
-		/// , the behavior is unspecified.
-		/// <p/>
-		/// For more information and an example, see
-		/// <see cref="Mark()">Mark()</see>
-		/// .
-		/// </summary>
-		/// <param name="marker">
-		/// A marker returned by a call to
-		/// <code>mark()</code>
-		/// .
-		/// </param>
-		/// <seealso cref="Mark()">Mark()</seealso>
-		public abstract void Release(int marker);
+        /// <summary>
+        /// This method releases a marked range created by a call to
+        /// <see cref="Mark()">mark()</see>
+        /// . Calls to
+        /// <code>release()</code>
+        /// must appear in the
+        /// reverse order of the corresponding calls to
+        /// <code>mark()</code>
+        /// . If a mark is
+        /// released twice, or if marks are not released in reverse order of the
+        /// corresponding calls to
+        /// <code>mark()</code>
+        /// , the behavior is unspecified.
+        /// <p/>
+        /// For more information and an example, see
+        /// <see cref="Mark()">Mark()</see>
+        /// .
+        /// </summary>
+        /// <param name="marker">
+        /// A marker returned by a call to
+        /// <code>mark()</code>
+        /// .
+        /// </param>
+        /// <seealso cref="Mark()">Mark()</seealso>
+        public abstract void Release(int marker);
 
-		/// <summary>
-		/// Return the index into the stream of the input symbol referred to by
-		/// <code>LA(1)</code>
-		/// .
-		/// <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.
-		/// </summary>
-		internal abstract int Index
-		{
-			get;
-		}
+        /// <summary>
+        /// Return the index into the stream of the input symbol referred to by
+        /// <code>LA(1)</code>
+        /// .
+        /// <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.
+        /// </summary>
+        internal abstract int Index
+        {
+            get;
+        }
 
-		/// <summary>
-		/// Set the input cursor to the position indicated by
-		/// <code>index</code>
-		/// . If the
-		/// specified index lies past the end of the stream, the operation behaves as
-		/// though
-		/// <code>index</code>
-		/// 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
-		/// <code>index</code>
-		/// . Specifically,
-		/// implementations which filter their sources should automatically
-		/// adjust
-		/// <code>index</code>
-		/// forward the minimum amount required for the
-		/// operation to target a non-ignored symbol.</li>
-		/// <li>
-		/// <code>LA(1)</code>
-		/// returns
-		/// <see cref="Eof">Eof</see>
-		/// </li>
-		/// </ul>
-		/// This operation is guaranteed to not throw an exception if
-		/// <code>index</code>
-		/// lies within a marked region. For more information on marked regions, see
-		/// <see cref="Mark()">Mark()</see>
-		/// . 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
-		/// <code>index</code>
-		/// is less than 0
-		/// </exception>
-		/// <exception cref="System.NotSupportedException">
-		/// if the stream does not support
-		/// seeking to the specified index
-		/// </exception>
-		public abstract void Seek(int index);
+        /// <summary>
+        /// Set the input cursor to the position indicated by
+        /// <code>index</code>
+        /// . If the
+        /// specified index lies past the end of the stream, the operation behaves as
+        /// though
+        /// <code>index</code>
+        /// 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
+        /// <code>index</code>
+        /// . Specifically,
+        /// implementations which filter their sources should automatically
+        /// adjust
+        /// <code>index</code>
+        /// forward the minimum amount required for the
+        /// operation to target a non-ignored symbol.</li>
+        /// <li>
+        /// <code>LA(1)</code>
+        /// returns
+        /// <see cref="Eof">Eof</see>
+        /// </li>
+        /// </ul>
+        /// This operation is guaranteed to not throw an exception if
+        /// <code>index</code>
+        /// lies within a marked region. For more information on marked regions, see
+        /// <see cref="Mark()">Mark()</see>
+        /// . 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
+        /// <code>index</code>
+        /// is less than 0
+        /// </exception>
+        /// <exception cref="System.NotSupportedException">
+        /// if the stream does not support
+        /// seeking to the specified index
+        /// </exception>
+        public abstract 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>
-		internal abstract int Size
-		{
-			get;
-		}
+        /// <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>
+        internal abstract 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="UnknownSourceName">UnknownSourceName</see>
-		/// .
-		/// </remarks>
-		public abstract string SourceName
-		{
-			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="UnknownSourceName">UnknownSourceName</see>
+        /// .
+        /// </remarks>
+        public abstract string SourceName
+        {
+            get;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/IParserErrorListener.cs b/Antlr4.Runtime/IParserErrorListener.cs
index 4cfcef675..ee60951b0 100644
--- a/Antlr4.Runtime/IParserErrorListener.cs
+++ b/Antlr4.Runtime/IParserErrorListener.cs
@@ -34,38 +34,38 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>How to emit recognition errors</summary>
-	public interface IParserErrorListener : IAntlrErrorListener<IToken>
-	{
-		/// <summary>
-		/// Called when the parser detects a true ambiguity: an input sequence can be matched
-		/// literally by two or more pass through the grammar.
-		/// </summary>
-		/// <remarks>
-		/// Called when the parser detects a true ambiguity: an input sequence can be matched
-		/// literally by two or more pass through the grammar. ANTLR resolves the ambiguity in
-		/// favor of the alternative appearing first in the grammar. The start and stop index are
-		/// zero-based absolute indices into the token stream. ambigAlts is a set of alternative numbers
-		/// that can match the input sequence. This method is only called when we are parsing with
-		/// full context.
-		/// </remarks>
-		void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet
-			 ambigAlts, ATNConfigSet configs);
+    /// <summary>How to emit recognition errors</summary>
+    public interface IParserErrorListener : IAntlrErrorListener<IToken>
+    {
+        /// <summary>
+        /// Called when the parser detects a true ambiguity: an input sequence can be matched
+        /// literally by two or more pass through the grammar.
+        /// </summary>
+        /// <remarks>
+        /// Called when the parser detects a true ambiguity: an input sequence can be matched
+        /// literally by two or more pass through the grammar. ANTLR resolves the ambiguity in
+        /// favor of the alternative appearing first in the grammar. The start and stop index are
+        /// zero-based absolute indices into the token stream. ambigAlts is a set of alternative numbers
+        /// that can match the input sequence. This method is only called when we are parsing with
+        /// full context.
+        /// </remarks>
+        void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet
+             ambigAlts, ATNConfigSet configs);
 
-		void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int 
-			stopIndex, SimulatorState initialState);
+        void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int 
+            stopIndex, SimulatorState initialState);
 
-		/// <summary>
-		/// Called by the parser when it find a conflict that is resolved by retrying the parse
-		/// with full context.
-		/// </summary>
-		/// <remarks>
-		/// Called by the parser when it find a conflict that is resolved by retrying the parse
-		/// with full context. This is not a warning; it simply notifies you that your grammar
-		/// is more complicated than Strong LL can handle. The parser moved up to full context
-		/// parsing for that input sequence.
-		/// </remarks>
-		void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex
-			, SimulatorState acceptState);
-	}
+        /// <summary>
+        /// Called by the parser when it find a conflict that is resolved by retrying the parse
+        /// with full context.
+        /// </summary>
+        /// <remarks>
+        /// Called by the parser when it find a conflict that is resolved by retrying the parse
+        /// with full context. This is not a warning; it simply notifies you that your grammar
+        /// is more complicated than Strong LL can handle. The parser moved up to full context
+        /// parsing for that input sequence.
+        /// </remarks>
+        void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex
+            , SimulatorState acceptState);
+    }
 }
diff --git a/Antlr4.Runtime/IToken.cs b/Antlr4.Runtime/IToken.cs
index 58883fc53..813e713d8 100644
--- a/Antlr4.Runtime/IToken.cs
+++ b/Antlr4.Runtime/IToken.cs
@@ -32,152 +32,152 @@ using 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 abstract class IToken
-	{
-		public const int InvalidType = 0;
+    /// <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 abstract class IToken
+    {
+        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;
+        /// <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 MinUserTokenType = 1;
 
-		public const int Eof = IIntStream.Eof;
+        public const int Eof = IIntStream.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>
+        /// 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>
+        /// 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>Get the text of the token.</summary>
-		/// <remarks>Get the text of the token.</remarks>
-		internal abstract string Text
-		{
-			get;
-		}
+        /// <summary>Get the text of the token.</summary>
+        /// <remarks>Get the text of the token.</remarks>
+        internal abstract string Text
+        {
+            get;
+        }
 
-		/// <summary>Get the token type of the token.</summary>
-		/// <remarks>Get the token type of the token.</remarks>
-		internal abstract int Type
-		{
-			get;
-		}
+        /// <summary>Get the token type of the token.</summary>
+        /// <remarks>Get the token type of the token.</remarks>
+        internal abstract int Type
+        {
+            get;
+        }
 
-		/// <summary>
-		/// The line number on which the 1st character of this token was matched,
-		/// line=1..n
-		/// </summary>
-		internal abstract int Line
-		{
-			get;
-		}
+        /// <summary>
+        /// The line number on which the 1st character of this token was matched,
+        /// line=1..n
+        /// </summary>
+        internal abstract 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>
-		internal abstract int Column
-		{
-			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>
+        internal abstract 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>
-		internal abstract int Channel
-		{
-			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>
+        internal abstract 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>
-		internal abstract int TokenIndex
-		{
-			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>
+        internal abstract 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>
-		internal abstract int StartIndex
-		{
-			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>
+        internal abstract 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>
-		internal abstract int StopIndex
-		{
-			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>
+        internal abstract int StopIndex
+        {
+            get;
+        }
 
-		/// <summary>
-		/// Gets the
-		/// <see cref="ITokenSource">ITokenSource</see>
-		/// which created this token.
-		/// </summary>
-		internal abstract ITokenSource TokenSource
-		{
-			get;
-		}
+        /// <summary>
+        /// Gets the
+        /// <see cref="ITokenSource">ITokenSource</see>
+        /// which created this token.
+        /// </summary>
+        internal abstract ITokenSource TokenSource
+        {
+            get;
+        }
 
-		/// <summary>
-		/// Gets the
-		/// <see cref="ICharStream">ICharStream</see>
-		/// from which this token was derived.
-		/// </summary>
-		internal abstract ICharStream InputStream
-		{
-			get;
-		}
-	}
+        /// <summary>
+        /// Gets the
+        /// <see cref="ICharStream">ICharStream</see>
+        /// from which this token was derived.
+        /// </summary>
+        internal abstract ICharStream InputStream
+        {
+            get;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ITokenFactory.cs b/Antlr4.Runtime/ITokenFactory.cs
index 347ae7f51..2c7b6a74e 100644
--- a/Antlr4.Runtime/ITokenFactory.cs
+++ b/Antlr4.Runtime/ITokenFactory.cs
@@ -33,27 +33,27 @@ using 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>
-		IToken Create<_T0>(Tuple<_T0> source, int type, string text, int channel, int start
-			, int stop, int line, int charPositionInLine) where _T0:ITokenSource;
+    /// <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>
+        IToken Create<_T0>(Tuple<_T0> source, int type, string text, int channel, int start
+            , int stop, int line, int charPositionInLine) where _T0:ITokenSource;
 
-		/// <summary>Generically useful</summary>
-		IToken Create(int type, string text);
-	}
+        /// <summary>Generically useful</summary>
+        IToken Create(int type, string text);
+    }
 }
diff --git a/Antlr4.Runtime/ITokenSource.cs b/Antlr4.Runtime/ITokenSource.cs
index 5dd4e45a1..a03d3cc4c 100644
--- a/Antlr4.Runtime/ITokenSource.cs
+++ b/Antlr4.Runtime/ITokenSource.cs
@@ -32,79 +32,79 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// A source of tokens must provide a sequence of tokens via nextToken()
-	/// and also must reveal it's source of characters; CommonToken's text is
-	/// computed from a CharStream; it only store indices into the char stream.
-	/// </summary>
-	/// <remarks>
-	/// A source of tokens must provide a sequence of tokens via nextToken()
-	/// and also must reveal it's source of characters; CommonToken's text is
-	/// computed from a CharStream; it only store indices into the char stream.
-	/// 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 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.
-	/// </remarks>
-	public interface ITokenSource
-	{
-		/// <summary>Return a Token object from your input stream (usually a CharStream).</summary>
-		/// <remarks>
-		/// Return a Token object from your input stream (usually a CharStream).
-		/// 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.
-		/// </remarks>
-		IToken NextToken();
+    /// <summary>
+    /// A source of tokens must provide a sequence of tokens via nextToken()
+    /// and also must reveal it's source of characters; CommonToken's text is
+    /// computed from a CharStream; it only store indices into the char stream.
+    /// </summary>
+    /// <remarks>
+    /// A source of tokens must provide a sequence of tokens via nextToken()
+    /// and also must reveal it's source of characters; CommonToken's text is
+    /// computed from a CharStream; it only store indices into the char stream.
+    /// 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 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.
+    /// </remarks>
+    public interface ITokenSource
+    {
+        /// <summary>Return a Token object from your input stream (usually a CharStream).</summary>
+        /// <remarks>
+        /// Return a Token object from your input stream (usually a CharStream).
+        /// 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.
+        /// </remarks>
+        IToken NextToken();
 
-		int Line
-		{
-			get;
-		}
+        int Line
+        {
+            get;
+        }
 
-		int Column
-		{
-			get;
-		}
+        int Column
+        {
+            get;
+        }
 
-		/// <summary>
-		/// From what character stream was this token created?  You don't have to
-		/// implement but it's nice to know where a Token comes from if you have
-		/// include files etc...
-		/// </summary>
-		/// <remarks>
-		/// From what character stream was this token created?  You don't have to
-		/// implement but it's nice to know where a Token comes from if you have
-		/// include files etc... on the input.
-		/// </remarks>
-		ICharStream InputStream
-		{
-			get;
-		}
+        /// <summary>
+        /// From what character stream was this token created?  You don't have to
+        /// implement but it's nice to know where a Token comes from if you have
+        /// include files etc...
+        /// </summary>
+        /// <remarks>
+        /// From what character stream was this token created?  You don't have to
+        /// implement but it's nice to know where a Token comes from if you have
+        /// include files etc... on the input.
+        /// </remarks>
+        ICharStream InputStream
+        {
+            get;
+        }
 
-		/// <summary>
-		/// Where are you getting tokens from? normally the implication will simply
-		/// ask lexers input stream.
-		/// </summary>
-		/// <remarks>
-		/// Where are you getting tokens from? normally the implication will simply
-		/// ask lexers input stream.
-		/// </remarks>
-		string SourceName
-		{
-			get;
-		}
+        /// <summary>
+        /// Where are you getting tokens from? normally the implication will simply
+        /// ask lexers input stream.
+        /// </summary>
+        /// <remarks>
+        /// Where are you getting tokens from? normally the implication will simply
+        /// ask lexers input stream.
+        /// </remarks>
+        string SourceName
+        {
+            get;
+        }
 
-		/// <summary>Gets the factory used for constructing tokens.</summary>
-		/// <remarks>Gets the factory used for constructing tokens.</remarks>
-		/// <summary>Optional method that lets users set factory in lexer or other source</summary>
-		ITokenFactory TokenFactory
-		{
-			get;
-			set;
-		}
-	}
+        /// <summary>Gets the factory used for constructing tokens.</summary>
+        /// <remarks>Gets the factory used for constructing tokens.</remarks>
+        /// <summary>Optional method that lets users set factory in lexer or other source</summary>
+        ITokenFactory TokenFactory
+        {
+            get;
+            set;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ITokenStream.cs b/Antlr4.Runtime/ITokenStream.cs
index 596b77867..00346fab5 100644
--- a/Antlr4.Runtime/ITokenStream.cs
+++ b/Antlr4.Runtime/ITokenStream.cs
@@ -33,215 +33,215 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <summary>
-	/// An
-	/// <see cref="IIntStream">IIntStream</see>
-	/// whose symbols are
-	/// <see cref="IToken">IToken</see>
-	/// instances.
-	/// </summary>
-	public interface ITokenStream : IIntStream
-	{
-		/// <summary>
-		/// Get the
-		/// <see cref="IToken">IToken</see>
-		/// 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)">IIntStream.La(int)</see>
-		/// . In addition, when the preconditions of this method
-		/// are met, the return value is non-null and the value of
-		/// <code>LT(k).getType()==LA(k)</code>
-		/// .
-		/// </summary>
-		/// <seealso cref="IIntStream.La(int)">IIntStream.La(int)</seealso>
-		[NotNull]
-		IToken Lt(int k);
+    /// <summary>
+    /// An
+    /// <see cref="IIntStream">IIntStream</see>
+    /// whose symbols are
+    /// <see cref="IToken">IToken</see>
+    /// instances.
+    /// </summary>
+    public interface ITokenStream : IIntStream
+    {
+        /// <summary>
+        /// Get the
+        /// <see cref="IToken">IToken</see>
+        /// 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)">IIntStream.La(int)</see>
+        /// . In addition, when the preconditions of this method
+        /// are met, the return value is non-null and the value of
+        /// <code>LT(k).getType()==LA(k)</code>
+        /// .
+        /// </summary>
+        /// <seealso cref="IIntStream.La(int)">IIntStream.La(int)</seealso>
+        [NotNull]
+        IToken Lt(int k);
 
-		/// <summary>
-		/// Gets the
-		/// <see cref="IToken">IToken</see>
-		/// at the specified
-		/// <code>index</code>
-		/// 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)">IIntStream.Seek(int)</see>
-		/// . If the behavior of
-		/// <code>seek(index)</code>
-		/// is
-		/// unspecified for the current state and given
-		/// <code>index</code>
-		/// , then the
-		/// behavior of this method is also unspecified.
-		/// <p/>
-		/// The symbol referred to by
-		/// <code>index</code>
-		/// differs from
-		/// <code>seek()</code>
-		/// only
-		/// in the case of filtering streams where
-		/// <code>index</code>
-		/// lies before the end
-		/// of the stream. Unlike
-		/// <code>seek()</code>
-		/// , this method does not adjust
-		/// <code>index</code>
-		/// to point to a non-ignored symbol.
-		/// </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>
-		[NotNull]
-		IToken Get(int i);
+        /// <summary>
+        /// Gets the
+        /// <see cref="IToken">IToken</see>
+        /// at the specified
+        /// <code>index</code>
+        /// 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)">IIntStream.Seek(int)</see>
+        /// . If the behavior of
+        /// <code>seek(index)</code>
+        /// is
+        /// unspecified for the current state and given
+        /// <code>index</code>
+        /// , then the
+        /// behavior of this method is also unspecified.
+        /// <p/>
+        /// The symbol referred to by
+        /// <code>index</code>
+        /// differs from
+        /// <code>seek()</code>
+        /// only
+        /// in the case of filtering streams where
+        /// <code>index</code>
+        /// lies before the end
+        /// of the stream. Unlike
+        /// <code>seek()</code>
+        /// , this method does not adjust
+        /// <code>index</code>
+        /// to point to a non-ignored symbol.
+        /// </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>
+        [NotNull]
+        IToken Get(int i);
 
-		/// <summary>
-		/// Gets the underlying
-		/// <see cref="ITokenSource">ITokenSource</see>
-		/// which provides tokens for this
-		/// stream.
-		/// </summary>
-		ITokenSource TokenSource
-		{
-			get;
-		}
+        /// <summary>
+        /// Gets the underlying
+        /// <see cref="ITokenSource">ITokenSource</see>
+        /// which provides tokens for this
+        /// stream.
+        /// </summary>
+        ITokenSource TokenSource
+        {
+            get;
+        }
 
-		/// <summary>
-		/// Return the text of all tokens within the specified
-		/// <code>interval</code>
-		/// . This
-		/// method behaves like the following code (including potential exceptions
-		/// for violating preconditions of
-		/// <see cref="Get(int)">Get(int)</see>
-		/// , 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
-		/// <code>interval</code>
-		/// is
-		/// <code>null</code>
-		/// </exception>
-		[NotNull]
-		string GetText(Interval interval);
+        /// <summary>
+        /// Return the text of all tokens within the specified
+        /// <code>interval</code>
+        /// . This
+        /// method behaves like the following code (including potential exceptions
+        /// for violating preconditions of
+        /// <see cref="Get(int)">Get(int)</see>
+        /// , 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
+        /// <code>interval</code>
+        /// is
+        /// <code>null</code>
+        /// </exception>
+        [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()">IIntStream.Size()</see>
-		/// and
-		/// <see cref="GetText(Antlr4.Runtime.Misc.Interval)">GetText(Antlr4.Runtime.Misc.Interval)
-		/// 	</see>
-		/// , 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>
-		[NotNull]
-		string GetText();
+        /// <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()">IIntStream.Size()</see>
+        /// and
+        /// <see cref="GetText(Antlr4.Runtime.Misc.Interval)">GetText(Antlr4.Runtime.Misc.Interval)
+        ///     </see>
+        /// , 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>
+        [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)">GetText(Antlr4.Runtime.Misc.Interval)
-		/// 	</see>
-		/// , but may be
-		/// optimized by the specific implementation.
-		/// </p>
-		/// If
-		/// <code>ctx.getSourceInterval()</code>
-		/// does not return a valid interval of
-		/// tokens provided by this stream, the behavior is unspecified.
-		/// <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
-		/// <code>ctx</code>
-		/// .
-		/// </returns>
-		[NotNull]
-		string GetText(RuleContext ctx);
+        /// <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)">GetText(Antlr4.Runtime.Misc.Interval)
+        ///     </see>
+        /// , but may be
+        /// optimized by the specific implementation.
+        /// </p>
+        /// If
+        /// <code>ctx.getSourceInterval()</code>
+        /// does not return a valid interval of
+        /// tokens provided by this stream, the behavior is unspecified.
+        /// <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
+        /// <code>ctx</code>
+        /// .
+        /// </returns>
+        [NotNull]
+        string GetText(RuleContext ctx);
 
-		/// <summary>
-		/// Return the text of all tokens in this stream between
-		/// <code>start</code>
-		/// and
-		/// <code>stop</code>
-		/// (inclusive).
-		/// <p/>
-		/// If the specified
-		/// <code>start</code>
-		/// or
-		/// <code>stop</code>
-		/// token was not provided by
-		/// this stream, or if the
-		/// <code>stop</code>
-		/// occurred before the
-		/// <code>start</code>
-		/// token, the behavior is unspecified.
-		/// <p/>
-		/// For streams which ensure that the
-		/// <see cref="IToken.TokenIndex()">IToken.TokenIndex()</see>
-		/// 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.
-		/// <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
-		/// <code>start</code>
-		/// and
-		/// <code>stop</code>
-		/// tokens.
-		/// </returns>
-		/// <exception cref="System.NotSupportedException">
-		/// if this stream does not support
-		/// this method for the specified tokens
-		/// </exception>
-		[NotNull]
-		string GetText(IToken start, IToken stop);
-	}
+        /// <summary>
+        /// Return the text of all tokens in this stream between
+        /// <code>start</code>
+        /// and
+        /// <code>stop</code>
+        /// (inclusive).
+        /// <p/>
+        /// If the specified
+        /// <code>start</code>
+        /// or
+        /// <code>stop</code>
+        /// token was not provided by
+        /// this stream, or if the
+        /// <code>stop</code>
+        /// occurred before the
+        /// <code>start</code>
+        /// token, the behavior is unspecified.
+        /// <p/>
+        /// For streams which ensure that the
+        /// <see cref="IToken.TokenIndex()">IToken.TokenIndex()</see>
+        /// 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.
+        /// <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
+        /// <code>start</code>
+        /// and
+        /// <code>stop</code>
+        /// tokens.
+        /// </returns>
+        /// <exception cref="System.NotSupportedException">
+        /// if this stream does not support
+        /// this method for the specified tokens
+        /// </exception>
+        [NotNull]
+        string GetText(IToken start, IToken stop);
+    }
 }
diff --git a/Antlr4.Runtime/IWritableToken.cs b/Antlr4.Runtime/IWritableToken.cs
index add55022d..7dcf838f9 100644
--- a/Antlr4.Runtime/IWritableToken.cs
+++ b/Antlr4.Runtime/IWritableToken.cs
@@ -32,36 +32,36 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public interface IWritableToken : IToken
-	{
-		string Text
-		{
-			set;
-		}
+    public interface IWritableToken : IToken
+    {
+        string Text
+        {
+            set;
+        }
 
-		int Type
-		{
-			set;
-		}
+        int Type
+        {
+            set;
+        }
 
-		int Line
-		{
-			set;
-		}
+        int Line
+        {
+            set;
+        }
 
-		int Column
-		{
-			set;
-		}
+        int Column
+        {
+            set;
+        }
 
-		int Channel
-		{
-			set;
-		}
+        int Channel
+        {
+            set;
+        }
 
-		int TokenIndex
-		{
-			set;
-		}
-	}
+        int TokenIndex
+        {
+            set;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/InputMismatchException.cs b/Antlr4.Runtime/InputMismatchException.cs
index dc3a8210b..3b36692f8 100644
--- a/Antlr4.Runtime/InputMismatchException.cs
+++ b/Antlr4.Runtime/InputMismatchException.cs
@@ -32,23 +32,23 @@ using 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;
+    /// <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.GetInputStream()), recognizer._ctx)
-		{
-			this.SetOffendingToken(recognizer.GetCurrentToken());
-		}
-	}
+        public InputMismatchException(Parser recognizer) : base(recognizer, ((ITokenStream
+            )recognizer.GetInputStream()), recognizer._ctx)
+        {
+            this.SetOffendingToken(recognizer.GetCurrentToken());
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Lexer.cs b/Antlr4.Runtime/Lexer.cs
index 976248b5d..f479bbbf0 100644
--- a/Antlr4.Runtime/Lexer.cs
+++ b/Antlr4.Runtime/Lexer.cs
@@ -37,543 +37,543 @@ using 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;
+    /// <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 More = -2;
+        public const int More = -2;
 
-		public const int Skip = -3;
+        public const int Skip = -3;
 
-		public const int DefaultTokenChannel = IToken.DefaultChannel;
+        public const int DefaultTokenChannel = IToken.DefaultChannel;
 
-		public const int Hidden = IToken.HiddenChannel;
+        public const int Hidden = IToken.HiddenChannel;
 
-		public const int MinCharValue = '\u0000';
+        public const int MinCharValue = '\u0000';
 
-		public const int MaxCharValue = '\uFFFE';
+        public const int MaxCharValue = '\uFFFE';
 
-		public ICharStream _input;
+        public ICharStream _input;
 
-		protected internal Tuple<ITokenSource, ICharStream> _tokenFactorySourcePair;
+        protected internal Tuple<ITokenSource, ICharStream> _tokenFactorySourcePair;
 
-		/// <summary>How to create token objects</summary>
-		protected internal ITokenFactory _factory = CommonTokenFactory.Default;
+        /// <summary>How to create token objects</summary>
+        protected internal 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>
-		public IToken _token;
+        /// <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>
+        public 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>
-		public int _tokenStartCharIndex = -1;
+        /// <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>
+        public int _tokenStartCharIndex = -1;
 
-		/// <summary>The line on which the first character of the token resides</summary>
-		public int _tokenStartLine;
+        /// <summary>The line on which the first character of the token resides</summary>
+        public int _tokenStartLine;
 
-		/// <summary>The character position of first character within the line</summary>
-		public int _tokenStartCharPositionInLine;
+        /// <summary>The character position of first character within the line</summary>
+        public int _tokenStartCharPositionInLine;
 
-		/// <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>
-		public bool _hitEOF;
+        /// <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>
+        public bool _hitEOF;
 
-		/// <summary>The channel number for the current token</summary>
-		public int _channel;
+        /// <summary>The channel number for the current token</summary>
+        public int _channel;
 
-		/// <summary>The token type for the current token</summary>
-		public int _type;
+        /// <summary>The token type for the current token</summary>
+        public int _type;
 
-		public readonly IntegerStack _modeStack = new IntegerStack();
+        public readonly IntegerStack _modeStack = new IntegerStack();
 
-		public int _mode = Antlr4.Runtime.Lexer.DefaultMode;
+        public 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>
-		public string _text;
+        /// <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>
+        public string _text;
 
-		public Lexer(ICharStream input)
-		{
-			this._input = input;
-			this._tokenFactorySourcePair = Tuple.Create(this, input);
-		}
+        public Lexer(ICharStream input)
+        {
+            this._input = input;
+            this._tokenFactorySourcePair = Tuple.Create(this, input);
+        }
 
-		public virtual void Reset()
-		{
-			// wack Lexer state variables
-			if (_input != null)
-			{
-				_input.Seek(0);
-			}
-			// rewind the input
-			_token = null;
-			_type = IToken.InvalidType;
-			_channel = IToken.DefaultChannel;
-			_tokenStartCharIndex = -1;
-			_tokenStartCharPositionInLine = -1;
-			_tokenStartLine = -1;
-			_text = null;
-			_hitEOF = false;
-			_mode = Antlr4.Runtime.Lexer.DefaultMode;
-			_modeStack.Clear();
-			GetInterpreter().Reset();
-		}
+        public virtual void Reset()
+        {
+            // wack Lexer state variables
+            if (_input != null)
+            {
+                _input.Seek(0);
+            }
+            // rewind the input
+            _token = null;
+            _type = IToken.InvalidType;
+            _channel = IToken.DefaultChannel;
+            _tokenStartCharIndex = -1;
+            _tokenStartCharPositionInLine = -1;
+            _tokenStartLine = -1;
+            _text = null;
+            _hitEOF = false;
+            _mode = Antlr4.Runtime.Lexer.DefaultMode;
+            _modeStack.Clear();
+            GetInterpreter().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 = IToken.DefaultChannel;
-					_tokenStartCharIndex = _input.Index;
-					_tokenStartCharPositionInLine = GetInterpreter().GetCharPositionInLine();
-					_tokenStartLine = GetInterpreter().GetLine();
-					_text = null;
-					do
-					{
-						_type = IToken.InvalidType;
-						//				System.out.println("nextToken line "+tokenStartLine+" at "+((char)input.LA(1))+
-						//								   " in mode "+mode+
-						//								   " at index "+input.index());
-						int ttype;
-						try
-						{
-							ttype = GetInterpreter().Match(_input, _mode);
-						}
-						catch (LexerNoViableAltException e)
-						{
-							NotifyListeners(e);
-							// report error
-							Recover(e);
-							ttype = Skip;
-						}
-						if (_input.La(1) == IIntStream.Eof)
-						{
-							_hitEOF = true;
-						}
-						if (_type == IToken.InvalidType)
-						{
-							_type = ttype;
-						}
-						if (_type == Skip)
-						{
-							goto outer_continue;
-						}
-					}
-					while (_type == More);
-					if (_token == null)
-					{
-						Emit();
-					}
-					return _token;
+        /// <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 = IToken.DefaultChannel;
+                    _tokenStartCharIndex = _input.Index;
+                    _tokenStartCharPositionInLine = GetInterpreter().GetCharPositionInLine();
+                    _tokenStartLine = GetInterpreter().GetLine();
+                    _text = null;
+                    do
+                    {
+                        _type = IToken.InvalidType;
+                        //				System.out.println("nextToken line "+tokenStartLine+" at "+((char)input.LA(1))+
+                        //								   " in mode "+mode+
+                        //								   " at index "+input.index());
+                        int ttype;
+                        try
+                        {
+                            ttype = GetInterpreter().Match(_input, _mode);
+                        }
+                        catch (LexerNoViableAltException e)
+                        {
+                            NotifyListeners(e);
+                            // report error
+                            Recover(e);
+                            ttype = Skip;
+                        }
+                        if (_input.La(1) == IIntStream.Eof)
+                        {
+                            _hitEOF = true;
+                        }
+                        if (_type == IToken.InvalidType)
+                        {
+                            _type = ttype;
+                        }
+                        if (_type == Skip)
+                        {
+                            goto outer_continue;
+                        }
+                    }
+                    while (_type == More);
+                    if (_token == null)
+                    {
+                        Emit();
+                    }
+                    return _token;
 outer_continue: ;
-				}
+                }
 outer_break: ;
-			}
-			finally
-			{
-				// make sure we release marker after match or
-				// unbuffered char stream will keep buffering
-				_input.Release(tokenStartMarker);
-			}
-		}
+            }
+            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 = Skip;
-		}
+        /// <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 = Skip;
+        }
 
-		public virtual void More()
-		{
-			_type = More;
-		}
+        public virtual void More()
+        {
+            _type = More;
+        }
 
-		public virtual void Mode(int m)
-		{
-			_mode = m;
-		}
+        public virtual void Mode(int m)
+        {
+            _mode = m;
+        }
 
-		public virtual void PushMode(int m)
-		{
-			_modeStack.Push(_mode);
-			Mode(m);
-		}
+        public virtual void PushMode(int m)
+        {
+            _modeStack.Push(_mode);
+            Mode(m);
+        }
 
-		public virtual int PopMode()
-		{
-			if (_modeStack.IsEmpty())
-			{
-				throw new EmptyStackException();
-			}
-			Mode(_modeStack.Pop());
-			return _mode;
-		}
+        public virtual int PopMode()
+        {
+            if (_modeStack.IsEmpty())
+            {
+                throw new EmptyStackException();
+            }
+            Mode(_modeStack.Pop());
+            return _mode;
+        }
 
-		public virtual ITokenFactory TokenFactory
-		{
-			get
-			{
-				return _factory;
-			}
-			set
-			{
-				ITokenFactory factory = value;
-				this._factory = factory;
-			}
-		}
+        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(this, _input);
-			Reset();
-			this._input = input;
-			this._tokenFactorySourcePair = Tuple.Create(this, _input);
-		}
+        /// <summary>Set the char stream and reset the lexer</summary>
+        public virtual void SetInputStream(ICharStream input)
+        {
+            this._input = null;
+            this._tokenFactorySourcePair = Tuple.Create(this, _input);
+            Reset();
+            this._input = input;
+            this._tokenFactorySourcePair = Tuple.Create(this, _input);
+        }
 
-		public virtual string SourceName
-		{
-			get
-			{
-				return _input.SourceName;
-			}
-		}
+        public virtual string SourceName
+        {
+            get
+            {
+                return _input.SourceName;
+            }
+        }
 
-		public override IIntStream GetInputStream()
-		{
-			return _input;
-		}
+        public override IIntStream GetInputStream()
+        {
+            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>
+        /// 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
-				, GetCharIndex() - 1, _tokenStartLine, _tokenStartCharPositionInLine);
-			Emit(t);
-			return t;
-		}
+        /// <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
+                , GetCharIndex() - 1, _tokenStartLine, _tokenStartCharPositionInLine);
+            Emit(t);
+            return t;
+        }
 
-		public virtual IToken EmitEOF()
-		{
-			int cpos = Column;
-			// The character position for EOF is one beyond the position of
-			// the previous token's last character
-			if (_token != null)
-			{
-				int n = _token.StopIndex - _token.StartIndex + 1;
-				cpos = _token.Column + n;
-			}
-			IToken eof = _factory.Create(_tokenFactorySourcePair, IToken.Eof, null, IToken.DefaultChannel
-				, _input.Index, _input.Index - 1, Line, cpos);
-			Emit(eof);
-			return eof;
-		}
+        public virtual IToken EmitEOF()
+        {
+            int cpos = Column;
+            // The character position for EOF is one beyond the position of
+            // the previous token's last character
+            if (_token != null)
+            {
+                int n = _token.StopIndex - _token.StartIndex + 1;
+                cpos = _token.Column + n;
+            }
+            IToken eof = _factory.Create(_tokenFactorySourcePair, IToken.Eof, null, IToken.DefaultChannel
+                , _input.Index, _input.Index - 1, Line, cpos);
+            Emit(eof);
+            return eof;
+        }
 
-		public virtual int Line
-		{
-			get
-			{
-				return GetInterpreter().GetLine();
-			}
-		}
+        public virtual int Line
+        {
+            get
+            {
+                return GetInterpreter().GetLine();
+            }
+        }
 
-		public virtual int Column
-		{
-			get
-			{
-				return GetInterpreter().GetCharPositionInLine();
-			}
-		}
+        public virtual int Column
+        {
+            get
+            {
+                return GetInterpreter().GetCharPositionInLine();
+            }
+        }
 
-		public virtual void SetLine(int line)
-		{
-			GetInterpreter().SetLine(line);
-		}
+        public virtual void SetLine(int line)
+        {
+            GetInterpreter().SetLine(line);
+        }
 
-		public virtual void SetCharPositionInLine(int charPositionInLine)
-		{
-			GetInterpreter().SetCharPositionInLine(charPositionInLine);
-		}
+        public virtual void SetCharPositionInLine(int charPositionInLine)
+        {
+            GetInterpreter().SetCharPositionInLine(charPositionInLine);
+        }
 
-		/// <summary>What is the index of the current character of lookahead?</summary>
-		public virtual int GetCharIndex()
-		{
-			return _input.Index;
-		}
+        /// <summary>What is the index of the current character of lookahead?</summary>
+        public virtual int GetCharIndex()
+        {
+            return _input.Index;
+        }
 
-		/// <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>
-		public virtual string GetText()
-		{
-			if (_text != null)
-			{
-				return _text;
-			}
-			return GetInterpreter().GetText(_input);
-		}
+        /// <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>
+        public virtual string GetText()
+        {
+            if (_text != null)
+            {
+                return _text;
+            }
+            return GetInterpreter().GetText(_input);
+        }
 
-		/// <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 void SetText(string text)
-		{
-			this._text = text;
-		}
+        /// <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 void SetText(string text)
+        {
+            this._text = text;
+        }
 
-		/// <summary>Override if emitting multiple tokens.</summary>
-		/// <remarks>Override if emitting multiple tokens.</remarks>
-		public virtual IToken GetToken()
-		{
-			return _token;
-		}
+        /// <summary>Override if emitting multiple tokens.</summary>
+        /// <remarks>Override if emitting multiple tokens.</remarks>
+        public virtual IToken GetToken()
+        {
+            return _token;
+        }
 
-		public virtual void SetToken(IToken _token)
-		{
-			this._token = _token;
-		}
+        public virtual void SetToken(IToken _token)
+        {
+            this._token = _token;
+        }
 
-		public virtual void SetType(int ttype)
-		{
-			_type = ttype;
-		}
+        public virtual void SetType(int ttype)
+        {
+            _type = ttype;
+        }
 
-		public virtual int GetType()
-		{
-			return _type;
-		}
+        public virtual int GetType()
+        {
+            return _type;
+        }
 
-		public virtual void SetChannel(int channel)
-		{
-			_channel = channel;
-		}
+        public virtual void SetChannel(int channel)
+        {
+            _channel = channel;
+        }
 
-		public virtual int GetChannel()
-		{
-			return _channel;
-		}
+        public virtual int GetChannel()
+        {
+            return _channel;
+        }
 
-		public virtual string[] GetModeNames()
-		{
-			return null;
-		}
+        public virtual string[] GetModeNames()
+        {
+            return null;
+        }
 
-		/// <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 override string[] GetTokenNames()
-		{
-			return null;
-		}
+        /// <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 override string[] GetTokenNames()
+        {
+            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 != IToken.Eof)
-			{
-				tokens.AddItem(t);
-				t = NextToken();
-			}
-			return tokens;
-		}
+        /// <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 != IToken.Eof)
+            {
+                tokens.AddItem(t);
+                t = NextToken();
+            }
+            return tokens;
+        }
 
-		public virtual void Recover(LexerNoViableAltException e)
-		{
-			if (_input.La(1) != IIntStream.Eof)
-			{
-				// skip a char and try again
-				GetInterpreter().Consume(_input);
-			}
-		}
+        public virtual void Recover(LexerNoViableAltException e)
+        {
+            if (_input.La(1) != IIntStream.Eof)
+            {
+                // skip a char and try again
+                GetInterpreter().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 = GetErrorListenerDispatch();
-			listener.SyntaxError(this, null, _tokenStartLine, _tokenStartCharPositionInLine, 
-				msg, e);
-		}
+        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 = GetErrorListenerDispatch();
+            listener.SyntaxError(this, null, _tokenStartLine, _tokenStartCharPositionInLine, 
+                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(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 IToken.Eof:
-				{
-					s = "<EOF>";
-					break;
-				}
+        public virtual string GetErrorDisplay(int c)
+        {
+            string s = (char)c.ToString();
+            switch (c)
+            {
+                case IToken.Eof:
+                {
+                    s = "<EOF>";
+                    break;
+                }
 
-				case '\n':
-				{
-					s = "\\n";
-					break;
-				}
+                case '\n':
+                {
+                    s = "\\n";
+                    break;
+                }
 
-				case '\t':
-				{
-					s = "\\t";
-					break;
-				}
+                case '\t':
+                {
+                    s = "\\t";
+                    break;
+                }
 
-				case '\r':
-				{
-					s = "\\r";
-					break;
-				}
-			}
-			return s;
-		}
+                case '\r':
+                {
+                    s = "\\r";
+                    break;
+                }
+            }
+            return s;
+        }
 
-		public virtual string GetCharErrorDisplay(int c)
-		{
-			string s = GetErrorDisplay(c);
-			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();
-		}
-	}
+        /// <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/Antlr4.Runtime/LexerNoViableAltException.cs b/Antlr4.Runtime/LexerNoViableAltException.cs
index fa5d19b6d..baa8bb786 100644
--- a/Antlr4.Runtime/LexerNoViableAltException.cs
+++ b/Antlr4.Runtime/LexerNoViableAltException.cs
@@ -34,53 +34,53 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	[System.Serializable]
-	public class LexerNoViableAltException : RecognitionException
-	{
-		private const long serialVersionUID = -730999203913001726L;
+    [System.Serializable]
+    public class LexerNoViableAltException : RecognitionException
+    {
+        private const long serialVersionUID = -730999203913001726L;
 
-		/// <summary>Matching attempted at what input index?</summary>
-		private readonly int startIndex;
+        /// <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;
+        /// <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 LexerNoViableAltException(Lexer lexer, ICharStream input, int startIndex, 
+            ATNConfigSet deadEndConfigs) : base(lexer, input)
+        {
+            this.startIndex = startIndex;
+            this.deadEndConfigs = deadEndConfigs;
+        }
 
-		public virtual int GetStartIndex()
-		{
-			return startIndex;
-		}
+        public virtual int GetStartIndex()
+        {
+            return startIndex;
+        }
 
-		[Nullable]
-		public virtual ATNConfigSet GetDeadEndConfigs()
-		{
-			return deadEndConfigs;
-		}
+        [Nullable]
+        public virtual ATNConfigSet GetDeadEndConfigs()
+        {
+            return deadEndConfigs;
+        }
 
-		public override IIntStream GetInputStream()
-		{
-			return (ICharStream)base.GetInputStream();
-		}
+        public override IIntStream GetInputStream()
+        {
+            return (ICharStream)base.GetInputStream();
+        }
 
-		public override string ToString()
-		{
-			string symbol = string.Empty;
-			if (startIndex >= 0 && startIndex < ((ICharStream)GetInputStream()).Size)
-			{
-				symbol = ((ICharStream)GetInputStream()).GetText(Interval.Of(startIndex, startIndex
-					));
-				symbol = Utils.EscapeWhitespace(symbol, false);
-			}
-			return string.Format("%s('%s')", typeof(Antlr4.Runtime.LexerNoViableAltException)
-				.Name, symbol);
-		}
-	}
+        public override string ToString()
+        {
+            string symbol = string.Empty;
+            if (startIndex >= 0 && startIndex < ((ICharStream)GetInputStream()).Size)
+            {
+                symbol = ((ICharStream)GetInputStream()).GetText(Interval.Of(startIndex, startIndex
+                    ));
+                symbol = Utils.EscapeWhitespace(symbol, false);
+            }
+            return string.Format("%s('%s')", typeof(Antlr4.Runtime.LexerNoViableAltException)
+                .Name, symbol);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/Args.cs b/Antlr4.Runtime/Misc/Args.cs
index 6a594e6a8..701e4e9d8 100644
--- a/Antlr4.Runtime/Misc/Args.cs
+++ b/Antlr4.Runtime/Misc/Args.cs
@@ -32,26 +32,26 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <author>Sam Harwell</author>
-	public sealed class Args
-	{
-		/// <exception cref="System.ArgumentNullException">
-		/// if
-		/// <code>value</code>
-		/// is
-		/// <code>null</code>
-		/// .
-		/// </exception>
-		public static void NotNull(string parameterName, object value)
-		{
-			if (value == null)
-			{
-				throw new ArgumentNullException(parameterName + " cannot be null.");
-			}
-		}
+    /// <author>Sam Harwell</author>
+    public sealed class Args
+    {
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <code>value</code>
+        /// is
+        /// <code>null</code>
+        /// .
+        /// </exception>
+        public static void NotNull(string parameterName, object value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(parameterName + " cannot be null.");
+            }
+        }
 
-		public Args()
-		{
-		}
-	}
+        public Args()
+        {
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/Array2DHashSet`1.cs b/Antlr4.Runtime/Misc/Array2DHashSet`1.cs
index e278bc8a6..d2495232e 100644
--- a/Antlr4.Runtime/Misc/Array2DHashSet`1.cs
+++ b/Antlr4.Runtime/Misc/Array2DHashSet`1.cs
@@ -35,658 +35,658 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>
-	/// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
-	/// implementation with closed hashing (open addressing).
-	/// </summary>
-	public class Array2DHashSet<T> : ICollection<T>
-	{
-		public const int InitalCapacity = 16;
+    /// <summary>
+    /// <see cref="Sharpen.ISet{E}">Sharpen.ISet&lt;E&gt;</see>
+    /// implementation with closed hashing (open addressing).
+    /// </summary>
+    public class Array2DHashSet<T> : ICollection<T>
+    {
+        public const int InitalCapacity = 16;
 
-		public const int InitalBucketCapacity = 8;
+        public const int InitalBucketCapacity = 8;
 
-		public const double LoadFactor = 0.75;
+        public const double LoadFactor = 0.75;
 
-		[NotNull]
-		protected internal readonly AbstractEqualityComparator<T> comparator;
+        [NotNull]
+        protected internal readonly AbstractEqualityComparator<T> comparator;
 
-		protected internal T[][] buckets;
+        protected internal T[][] buckets;
 
-		/// <summary>How many elements in set</summary>
-		protected internal int n = 0;
+        /// <summary>How many elements in set</summary>
+        protected internal int n = 0;
 
-		protected internal int threshold = (int)(InitalCapacity * LoadFactor);
+        protected internal int threshold = (int)(InitalCapacity * LoadFactor);
 
-		protected internal int currentPrime = 1;
+        protected internal int currentPrime = 1;
 
-		protected internal int initialBucketCapacity = InitalBucketCapacity;
+        protected internal int initialBucketCapacity = InitalBucketCapacity;
 
-		public Array2DHashSet() : this(null, InitalCapacity, InitalBucketCapacity)
-		{
-		}
+        public Array2DHashSet() : this(null, InitalCapacity, InitalBucketCapacity)
+        {
+        }
 
-		public Array2DHashSet(AbstractEqualityComparator<T> comparator) : this(comparator
-			, InitalCapacity, InitalBucketCapacity)
-		{
-		}
+        public Array2DHashSet(AbstractEqualityComparator<T> comparator) : this(comparator
+            , InitalCapacity, InitalBucketCapacity)
+        {
+        }
 
-		public Array2DHashSet(AbstractEqualityComparator<T> comparator, int initialCapacity
-			, int initialBucketCapacity)
-		{
-			// must be power of 2
-			// when to expand
-			// jump by 4 primes each expand or whatever
-			if (comparator == null)
-			{
-				comparator = ObjectEqualityComparator.Instance;
-			}
-			this.comparator = comparator;
-			this.buckets = CreateBuckets(initialCapacity);
-			this.initialBucketCapacity = initialBucketCapacity;
-		}
+        public Array2DHashSet(AbstractEqualityComparator<T> comparator, int initialCapacity
+            , int initialBucketCapacity)
+        {
+            // must be power of 2
+            // when to expand
+            // jump by 4 primes each expand or whatever
+            if (comparator == null)
+            {
+                comparator = ObjectEqualityComparator.Instance;
+            }
+            this.comparator = comparator;
+            this.buckets = CreateBuckets(initialCapacity);
+            this.initialBucketCapacity = initialBucketCapacity;
+        }
 
-		/// <summary>
-		/// Add
-		/// <code>o</code>
-		/// to set if not there; return existing value if already
-		/// there. This method performs the same operation as
-		/// <see cref="Array2DHashSet{T}.AddItem(object)">Array2DHashSet&lt;T&gt;.AddItem(object)
-		/// 	</see>
-		/// aside from
-		/// the return value.
-		/// </summary>
-		public T GetOrAdd(T o)
-		{
-			if (n > threshold)
-			{
-				Expand();
-			}
-			return GetOrAddImpl(o);
-		}
+        /// <summary>
+        /// Add
+        /// <code>o</code>
+        /// to set if not there; return existing value if already
+        /// there. This method performs the same operation as
+        /// <see cref="Array2DHashSet{T}.AddItem(object)">Array2DHashSet&lt;T&gt;.AddItem(object)
+        ///     </see>
+        /// aside from
+        /// the return value.
+        /// </summary>
+        public T GetOrAdd(T o)
+        {
+            if (n > threshold)
+            {
+                Expand();
+            }
+            return GetOrAddImpl(o);
+        }
 
-		protected internal virtual T GetOrAddImpl(T o)
-		{
-			int b = GetBucket(o);
-			T[] bucket = buckets[b];
-			// NEW BUCKET
-			if (bucket == null)
-			{
-				bucket = CreateBucket(initialBucketCapacity);
-				bucket[0] = o;
-				buckets[b] = bucket;
-				n++;
-				return o;
-			}
-			// LOOK FOR IT IN BUCKET
-			for (int i = 0; i < bucket.Length; i++)
-			{
-				T existing = bucket[i];
-				if (existing == null)
-				{
-					// empty slot; not there, add.
-					bucket[i] = o;
-					n++;
-					return o;
-				}
-				if (comparator.Equals(existing, o))
-				{
-					return existing;
-				}
-			}
-			// found existing, quit
-			// FULL BUCKET, expand and add to end
-			int oldLength = bucket.Length;
-			bucket = Arrays.CopyOf(bucket, bucket.Length * 2);
-			buckets[b] = bucket;
-			bucket[oldLength] = o;
-			// add to end
-			n++;
-			return o;
-		}
+        protected internal virtual T GetOrAddImpl(T o)
+        {
+            int b = GetBucket(o);
+            T[] bucket = buckets[b];
+            // NEW BUCKET
+            if (bucket == null)
+            {
+                bucket = CreateBucket(initialBucketCapacity);
+                bucket[0] = o;
+                buckets[b] = bucket;
+                n++;
+                return o;
+            }
+            // LOOK FOR IT IN BUCKET
+            for (int i = 0; i < bucket.Length; i++)
+            {
+                T existing = bucket[i];
+                if (existing == null)
+                {
+                    // empty slot; not there, add.
+                    bucket[i] = o;
+                    n++;
+                    return o;
+                }
+                if (comparator.Equals(existing, o))
+                {
+                    return existing;
+                }
+            }
+            // found existing, quit
+            // FULL BUCKET, expand and add to end
+            int oldLength = bucket.Length;
+            bucket = Arrays.CopyOf(bucket, bucket.Length * 2);
+            buckets[b] = bucket;
+            bucket[oldLength] = o;
+            // add to end
+            n++;
+            return o;
+        }
 
-		public virtual T Get(T o)
-		{
-			if (o == null)
-			{
-				return o;
-			}
-			int b = GetBucket(o);
-			T[] bucket = buckets[b];
-			if (bucket == null)
-			{
-				return null;
-			}
-			// no bucket
-			foreach (T e in bucket)
-			{
-				if (e == null)
-				{
-					return null;
-				}
-				// empty slot; not there
-				if (comparator.Equals(e, o))
-				{
-					return e;
-				}
-			}
-			return null;
-		}
+        public virtual T Get(T o)
+        {
+            if (o == null)
+            {
+                return o;
+            }
+            int b = GetBucket(o);
+            T[] bucket = buckets[b];
+            if (bucket == null)
+            {
+                return null;
+            }
+            // no bucket
+            foreach (T e in bucket)
+            {
+                if (e == null)
+                {
+                    return null;
+                }
+                // empty slot; not there
+                if (comparator.Equals(e, o))
+                {
+                    return e;
+                }
+            }
+            return null;
+        }
 
-		protected internal int GetBucket(T o)
-		{
-			int hash = comparator.HashCode(o);
-			int b = hash & (buckets.Length - 1);
-			// assumes len is power of 2
-			return b;
-		}
+        protected internal int GetBucket(T o)
+        {
+            int hash = comparator.HashCode(o);
+            int b = hash & (buckets.Length - 1);
+            // assumes len is power of 2
+            return b;
+        }
 
-		public override int GetHashCode()
-		{
-			int h = 0;
-			foreach (T[] bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (T o in bucket)
-				{
-					if (o == null)
-					{
-						break;
-					}
-					h += comparator.HashCode(o);
-				}
-			}
-			return h;
-		}
+        public override int GetHashCode()
+        {
+            int h = 0;
+            foreach (T[] bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (T o in bucket)
+                {
+                    if (o == null)
+                    {
+                        break;
+                    }
+                    h += comparator.HashCode(o);
+                }
+            }
+            return h;
+        }
 
-		public override bool Equals(object o)
-		{
-			if (o == this)
-			{
-				return true;
-			}
-			if (!(o is Antlr4.Runtime.Misc.Array2DHashSet))
-			{
-				return false;
-			}
-			Antlr4.Runtime.Misc.Array2DHashSet<object> other = (Antlr4.Runtime.Misc.Array2DHashSet
-				<object>)o;
-			if (other.Count != Count)
-			{
-				return false;
-			}
-			bool same = this.ContainsAll(other);
-			return same;
-		}
+        public override bool Equals(object o)
+        {
+            if (o == this)
+            {
+                return true;
+            }
+            if (!(o is Antlr4.Runtime.Misc.Array2DHashSet))
+            {
+                return false;
+            }
+            Antlr4.Runtime.Misc.Array2DHashSet<object> other = (Antlr4.Runtime.Misc.Array2DHashSet
+                <object>)o;
+            if (other.Count != Count)
+            {
+                return false;
+            }
+            bool same = this.ContainsAll(other);
+            return same;
+        }
 
-		protected internal virtual void Expand()
-		{
-			T[][] old = buckets;
-			currentPrime += 4;
-			int newCapacity = buckets.Length * 2;
-			T[][] newTable = CreateBuckets(newCapacity);
-			int[] newBucketLengths = new int[newTable.Length];
-			buckets = newTable;
-			threshold = (int)(newCapacity * LoadFactor);
-			//		System.out.println("new size="+newCapacity+", thres="+threshold);
-			// rehash all existing entries
-			int oldSize = Count;
-			foreach (T[] bucket in old)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (T o in bucket)
-				{
-					if (o == null)
-					{
-						break;
-					}
-					int b = GetBucket(o);
-					int bucketLength = newBucketLengths[b];
-					T[] newBucket;
-					if (bucketLength == 0)
-					{
-						// new bucket
-						newBucket = CreateBucket(initialBucketCapacity);
-						newTable[b] = newBucket;
-					}
-					else
-					{
-						newBucket = newTable[b];
-						if (bucketLength == newBucket.Length)
-						{
-							// expand
-							newBucket = Arrays.CopyOf(newBucket, newBucket.Length * 2);
-							newTable[b] = newBucket;
-						}
-					}
-					newBucket[bucketLength] = o;
-					newBucketLengths[b]++;
-				}
-			}
-			System.Diagnostics.Debug.Assert(n == oldSize);
-		}
+        protected internal virtual void Expand()
+        {
+            T[][] old = buckets;
+            currentPrime += 4;
+            int newCapacity = buckets.Length * 2;
+            T[][] newTable = CreateBuckets(newCapacity);
+            int[] newBucketLengths = new int[newTable.Length];
+            buckets = newTable;
+            threshold = (int)(newCapacity * LoadFactor);
+            //		System.out.println("new size="+newCapacity+", thres="+threshold);
+            // rehash all existing entries
+            int oldSize = Count;
+            foreach (T[] bucket in old)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (T o in bucket)
+                {
+                    if (o == null)
+                    {
+                        break;
+                    }
+                    int b = GetBucket(o);
+                    int bucketLength = newBucketLengths[b];
+                    T[] newBucket;
+                    if (bucketLength == 0)
+                    {
+                        // new bucket
+                        newBucket = CreateBucket(initialBucketCapacity);
+                        newTable[b] = newBucket;
+                    }
+                    else
+                    {
+                        newBucket = newTable[b];
+                        if (bucketLength == newBucket.Length)
+                        {
+                            // expand
+                            newBucket = Arrays.CopyOf(newBucket, newBucket.Length * 2);
+                            newTable[b] = newBucket;
+                        }
+                    }
+                    newBucket[bucketLength] = o;
+                    newBucketLengths[b]++;
+                }
+            }
+            System.Diagnostics.Debug.Assert(n == oldSize);
+        }
 
-		public bool AddItem(T t)
-		{
-			T existing = GetOrAdd(t);
-			return existing == t;
-		}
+        public bool AddItem(T t)
+        {
+            T existing = GetOrAdd(t);
+            return existing == t;
+        }
 
-		public int Count
-		{
-			get
-			{
-				return n;
-			}
-		}
+        public int Count
+        {
+            get
+            {
+                return n;
+            }
+        }
 
-		public bool IsEmpty()
-		{
-			return n == 0;
-		}
+        public bool IsEmpty()
+        {
+            return n == 0;
+        }
 
-		public bool Contains(object o)
-		{
-			return ContainsFast(AsElementType(o));
-		}
+        public bool Contains(object o)
+        {
+            return ContainsFast(AsElementType(o));
+        }
 
-		public virtual bool ContainsFast(T obj)
-		{
-			if (obj == null)
-			{
-				return false;
-			}
-			return Get(obj) != null;
-		}
+        public virtual bool ContainsFast(T obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+            return Get(obj) != null;
+        }
 
-		public virtual IEnumerator<T> GetEnumerator()
-		{
-			return new Array2DHashSet.SetIterator(this, Sharpen.Collections.ToArray(this));
-		}
+        public virtual IEnumerator<T> GetEnumerator()
+        {
+            return new Array2DHashSet.SetIterator(this, Sharpen.Collections.ToArray(this));
+        }
 
-		public virtual T[] ToArray()
-		{
-			T[] a = CreateBucket(Count);
-			int i = 0;
-			foreach (T[] bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (T o in bucket)
-				{
-					if (o == null)
-					{
-						break;
-					}
-					a[i++] = o;
-				}
-			}
-			return a;
-		}
+        public virtual T[] ToArray()
+        {
+            T[] a = CreateBucket(Count);
+            int i = 0;
+            foreach (T[] bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (T o in bucket)
+                {
+                    if (o == null)
+                    {
+                        break;
+                    }
+                    a[i++] = o;
+                }
+            }
+            return a;
+        }
 
-		public virtual U[] ToArray<U>(U[] a)
-		{
-			if (a.Length < Count)
-			{
-				a = Arrays.CopyOf(a, Count);
-			}
-			int i = 0;
-			foreach (T[] bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (T o in bucket)
-				{
-					if (o == null)
-					{
-						break;
-					}
-					U targetElement = (U)o;
-					// array store will check this
-					a[i++] = targetElement;
-				}
-			}
-			return a;
-		}
+        public virtual U[] ToArray<U>(U[] a)
+        {
+            if (a.Length < Count)
+            {
+                a = Arrays.CopyOf(a, Count);
+            }
+            int i = 0;
+            foreach (T[] bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (T o in bucket)
+                {
+                    if (o == null)
+                    {
+                        break;
+                    }
+                    U targetElement = (U)o;
+                    // array store will check this
+                    a[i++] = targetElement;
+                }
+            }
+            return a;
+        }
 
-		public bool Remove(object o)
-		{
-			return RemoveFast(AsElementType(o));
-		}
+        public bool Remove(object o)
+        {
+            return RemoveFast(AsElementType(o));
+        }
 
-		public virtual bool RemoveFast(T obj)
-		{
-			if (obj == null)
-			{
-				return false;
-			}
-			int b = GetBucket(obj);
-			T[] bucket = buckets[b];
-			if (bucket == null)
-			{
-				// no bucket
-				return false;
-			}
-			for (int i = 0; i < bucket.Length; i++)
-			{
-				T e = bucket[i];
-				if (e == null)
-				{
-					// empty slot; not there
-					return false;
-				}
-				if (comparator.Equals(e, obj))
-				{
-					// found it
-					// shift all elements to the right down one
-					System.Array.Copy(bucket, i + 1, bucket, i, bucket.Length - i - 1);
-					bucket[bucket.Length - 1] = null;
-					n--;
-					return true;
-				}
-			}
-			return false;
-		}
+        public virtual bool RemoveFast(T obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+            int b = GetBucket(obj);
+            T[] bucket = buckets[b];
+            if (bucket == null)
+            {
+                // no bucket
+                return false;
+            }
+            for (int i = 0; i < bucket.Length; i++)
+            {
+                T e = bucket[i];
+                if (e == null)
+                {
+                    // empty slot; not there
+                    return false;
+                }
+                if (comparator.Equals(e, obj))
+                {
+                    // found it
+                    // shift all elements to the right down one
+                    System.Array.Copy(bucket, i + 1, bucket, i, bucket.Length - i - 1);
+                    bucket[bucket.Length - 1] = null;
+                    n--;
+                    return true;
+                }
+            }
+            return false;
+        }
 
-		public virtual bool ContainsAll<_T0>(ICollection<_T0> collection)
-		{
-			if (collection is Antlr4.Runtime.Misc.Array2DHashSet)
-			{
-				Antlr4.Runtime.Misc.Array2DHashSet<object> s = (Antlr4.Runtime.Misc.Array2DHashSet
-					<object>)collection;
-				foreach (object[] bucket in s.buckets)
-				{
-					if (bucket == null)
-					{
-						continue;
-					}
-					foreach (object o in bucket)
-					{
-						if (o == null)
-						{
-							break;
-						}
-						if (!this.ContainsFast(AsElementType(o)))
-						{
-							return false;
-						}
-					}
-				}
-			}
-			else
-			{
-				foreach (object o in collection)
-				{
-					if (!this.ContainsFast(AsElementType(o)))
-					{
-						return false;
-					}
-				}
-			}
-			return true;
-		}
+        public virtual bool ContainsAll<_T0>(ICollection<_T0> collection)
+        {
+            if (collection is Antlr4.Runtime.Misc.Array2DHashSet)
+            {
+                Antlr4.Runtime.Misc.Array2DHashSet<object> s = (Antlr4.Runtime.Misc.Array2DHashSet
+                    <object>)collection;
+                foreach (object[] bucket in s.buckets)
+                {
+                    if (bucket == null)
+                    {
+                        continue;
+                    }
+                    foreach (object o in bucket)
+                    {
+                        if (o == null)
+                        {
+                            break;
+                        }
+                        if (!this.ContainsFast(AsElementType(o)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                foreach (object o in collection)
+                {
+                    if (!this.ContainsFast(AsElementType(o)))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
 
-		public virtual bool AddAll<_T0>(ICollection<_T0> c) where _T0:T
-		{
-			bool changed = false;
-			foreach (T o in c)
-			{
-				T existing = GetOrAdd(o);
-				if (existing != o)
-				{
-					changed = true;
-				}
-			}
-			return changed;
-		}
+        public virtual bool AddAll<_T0>(ICollection<_T0> c) where _T0:T
+        {
+            bool changed = false;
+            foreach (T o in c)
+            {
+                T existing = GetOrAdd(o);
+                if (existing != o)
+                {
+                    changed = true;
+                }
+            }
+            return changed;
+        }
 
-		public virtual bool RetainAll<_T0>(ICollection<_T0> c)
-		{
-			int newsize = 0;
-			foreach (T[] bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				int i;
-				int j;
-				for (i = 0, j = 0; i < bucket.Length; i++)
-				{
-					if (bucket[i] == null)
-					{
-						break;
-					}
-					if (!c.Contains(bucket[i]))
-					{
-						// removed
-						continue;
-					}
-					// keep
-					if (i != j)
-					{
-						bucket[j] = bucket[i];
-					}
-					j++;
-					newsize++;
-				}
-				newsize += j;
-				while (j < i)
-				{
-					bucket[j] = null;
-					j++;
-				}
-			}
-			bool changed = newsize != n;
-			n = newsize;
-			return changed;
-		}
+        public virtual bool RetainAll<_T0>(ICollection<_T0> c)
+        {
+            int newsize = 0;
+            foreach (T[] bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                int i;
+                int j;
+                for (i = 0, j = 0; i < bucket.Length; i++)
+                {
+                    if (bucket[i] == null)
+                    {
+                        break;
+                    }
+                    if (!c.Contains(bucket[i]))
+                    {
+                        // removed
+                        continue;
+                    }
+                    // keep
+                    if (i != j)
+                    {
+                        bucket[j] = bucket[i];
+                    }
+                    j++;
+                    newsize++;
+                }
+                newsize += j;
+                while (j < i)
+                {
+                    bucket[j] = null;
+                    j++;
+                }
+            }
+            bool changed = newsize != n;
+            n = newsize;
+            return changed;
+        }
 
-		public virtual bool RemoveAll<_T0>(ICollection<_T0> c)
-		{
-			bool changed = false;
-			foreach (object o in c)
-			{
-				changed |= RemoveFast(AsElementType(o));
-			}
-			return changed;
-		}
+        public virtual bool RemoveAll<_T0>(ICollection<_T0> c)
+        {
+            bool changed = false;
+            foreach (object o in c)
+            {
+                changed |= RemoveFast(AsElementType(o));
+            }
+            return changed;
+        }
 
-		public virtual void Clear()
-		{
-			buckets = CreateBuckets(InitalCapacity);
-			n = 0;
-		}
+        public virtual void Clear()
+        {
+            buckets = CreateBuckets(InitalCapacity);
+            n = 0;
+        }
 
-		public override string ToString()
-		{
-			if (Count == 0)
-			{
-				return "{}";
-			}
-			StringBuilder buf = new StringBuilder();
-			buf.Append('{');
-			bool first = true;
-			foreach (T[] bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (T o in bucket)
-				{
-					if (o == null)
-					{
-						break;
-					}
-					if (first)
-					{
-						first = false;
-					}
-					else
-					{
-						buf.Append(", ");
-					}
-					buf.Append(o.ToString());
-				}
-			}
-			buf.Append('}');
-			return buf.ToString();
-		}
+        public override string ToString()
+        {
+            if (Count == 0)
+            {
+                return "{}";
+            }
+            StringBuilder buf = new StringBuilder();
+            buf.Append('{');
+            bool first = true;
+            foreach (T[] bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (T o in bucket)
+                {
+                    if (o == null)
+                    {
+                        break;
+                    }
+                    if (first)
+                    {
+                        first = false;
+                    }
+                    else
+                    {
+                        buf.Append(", ");
+                    }
+                    buf.Append(o.ToString());
+                }
+            }
+            buf.Append('}');
+            return buf.ToString();
+        }
 
-		public virtual string ToTableString()
-		{
-			StringBuilder buf = new StringBuilder();
-			foreach (T[] bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					buf.Append("null\n");
-					continue;
-				}
-				buf.Append('[');
-				bool first = true;
-				foreach (T o in bucket)
-				{
-					if (first)
-					{
-						first = false;
-					}
-					else
-					{
-						buf.Append(" ");
-					}
-					if (o == null)
-					{
-						buf.Append("_");
-					}
-					else
-					{
-						buf.Append(o.ToString());
-					}
-				}
-				buf.Append("]\n");
-			}
-			return buf.ToString();
-		}
+        public virtual string ToTableString()
+        {
+            StringBuilder buf = new StringBuilder();
+            foreach (T[] bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    buf.Append("null\n");
+                    continue;
+                }
+                buf.Append('[');
+                bool first = true;
+                foreach (T o in bucket)
+                {
+                    if (first)
+                    {
+                        first = false;
+                    }
+                    else
+                    {
+                        buf.Append(" ");
+                    }
+                    if (o == null)
+                    {
+                        buf.Append("_");
+                    }
+                    else
+                    {
+                        buf.Append(o.ToString());
+                    }
+                }
+                buf.Append("]\n");
+            }
+            return buf.ToString();
+        }
 
-		/// <summary>
-		/// Return
-		/// <code>o</code>
-		/// as an instance of the element type
-		/// <code>T</code>
-		/// . If
-		/// <code>o</code>
-		/// is non-null but known to not be an instance of
-		/// <code>T</code>
-		/// , this
-		/// method returns
-		/// <code>null</code>
-		/// . The base implementation does not perform any
-		/// type checks; override this method to provide strong type checks for the
-		/// <see cref="Array2DHashSet{T}.Contains(object)">Array2DHashSet&lt;T&gt;.Contains(object)
-		/// 	</see>
-		/// and
-		/// <see cref="Array2DHashSet{T}.Remove(object)">Array2DHashSet&lt;T&gt;.Remove(object)
-		/// 	</see>
-		/// methods to ensure the arguments to
-		/// the
-		/// <see cref="IEqualityComparator{T}">IEqualityComparator&lt;T&gt;</see>
-		/// for the set always have the expected
-		/// types.
-		/// </summary>
-		/// <param name="o">the object to try and cast to the element type of the set</param>
-		/// <returns>
-		/// 
-		/// <code>o</code>
-		/// if it could be an instance of
-		/// <code>T</code>
-		/// , otherwise
-		/// <code>null</code>
-		/// .
-		/// </returns>
-		protected internal virtual T AsElementType(object o)
-		{
-			return (T)o;
-		}
+        /// <summary>
+        /// Return
+        /// <code>o</code>
+        /// as an instance of the element type
+        /// <code>T</code>
+        /// . If
+        /// <code>o</code>
+        /// is non-null but known to not be an instance of
+        /// <code>T</code>
+        /// , this
+        /// method returns
+        /// <code>null</code>
+        /// . The base implementation does not perform any
+        /// type checks; override this method to provide strong type checks for the
+        /// <see cref="Array2DHashSet{T}.Contains(object)">Array2DHashSet&lt;T&gt;.Contains(object)
+        ///     </see>
+        /// and
+        /// <see cref="Array2DHashSet{T}.Remove(object)">Array2DHashSet&lt;T&gt;.Remove(object)
+        ///     </see>
+        /// methods to ensure the arguments to
+        /// the
+        /// <see cref="IEqualityComparator{T}">IEqualityComparator&lt;T&gt;</see>
+        /// for the set always have the expected
+        /// types.
+        /// </summary>
+        /// <param name="o">the object to try and cast to the element type of the set</param>
+        /// <returns>
+        /// 
+        /// <code>o</code>
+        /// if it could be an instance of
+        /// <code>T</code>
+        /// , otherwise
+        /// <code>null</code>
+        /// .
+        /// </returns>
+        protected internal virtual T AsElementType(object o)
+        {
+            return (T)o;
+        }
 
-		/// <summary>
-		/// Return an array of
-		/// <code>T[]</code>
-		/// with length
-		/// <code>capacity</code>
-		/// .
-		/// </summary>
-		/// <param name="capacity">the length of the array to return</param>
-		/// <returns>the newly constructed array</returns>
-		protected internal virtual T[][] CreateBuckets(int capacity)
-		{
-			return (T[][])new object[capacity][];
-		}
+        /// <summary>
+        /// Return an array of
+        /// <code>T[]</code>
+        /// with length
+        /// <code>capacity</code>
+        /// .
+        /// </summary>
+        /// <param name="capacity">the length of the array to return</param>
+        /// <returns>the newly constructed array</returns>
+        protected internal virtual T[][] CreateBuckets(int capacity)
+        {
+            return (T[][])new object[capacity][];
+        }
 
-		/// <summary>
-		/// Return an array of
-		/// <code>T</code>
-		/// with length
-		/// <code>capacity</code>
-		/// .
-		/// </summary>
-		/// <param name="capacity">the length of the array to return</param>
-		/// <returns>the newly constructed array</returns>
-		protected internal virtual T[] CreateBucket(int capacity)
-		{
-			return (T[])new object[capacity];
-		}
+        /// <summary>
+        /// Return an array of
+        /// <code>T</code>
+        /// with length
+        /// <code>capacity</code>
+        /// .
+        /// </summary>
+        /// <param name="capacity">the length of the array to return</param>
+        /// <returns>the newly constructed array</returns>
+        protected internal virtual T[] CreateBucket(int capacity)
+        {
+            return (T[])new object[capacity];
+        }
 
-		protected internal class SetIterator : IEnumerator<T>
-		{
-			internal readonly T[] data;
+        protected internal class SetIterator : IEnumerator<T>
+        {
+            internal readonly T[] data;
 
-			internal int nextIndex = 0;
+            internal int nextIndex = 0;
 
-			internal bool removed = true;
+            internal bool removed = true;
 
-			public SetIterator(Array2DHashSet<T> _enclosing, T[] data)
-			{
-				this._enclosing = _enclosing;
-				this.data = data;
-			}
+            public SetIterator(Array2DHashSet<T> _enclosing, T[] data)
+            {
+                this._enclosing = _enclosing;
+                this.data = data;
+            }
 
-			public override bool HasNext()
-			{
-				return this.nextIndex < this.data.Length;
-			}
+            public override bool HasNext()
+            {
+                return this.nextIndex < this.data.Length;
+            }
 
-			public override T Next()
-			{
-				if (!this.HasNext())
-				{
-					throw new NoSuchElementException();
-				}
-				this.removed = false;
-				return this.data[this.nextIndex++];
-			}
+            public override T Next()
+            {
+                if (!this.HasNext())
+                {
+                    throw new NoSuchElementException();
+                }
+                this.removed = false;
+                return this.data[this.nextIndex++];
+            }
 
-			public override void Remove()
-			{
-				if (this.removed)
-				{
-					throw new InvalidOperationException();
-				}
-				this._enclosing._enclosing.Remove(this.data[this.nextIndex - 1]);
-				this.removed = true;
-			}
+            public override void Remove()
+            {
+                if (this.removed)
+                {
+                    throw new InvalidOperationException();
+                }
+                this._enclosing._enclosing.Remove(this.data[this.nextIndex - 1]);
+                this.removed = true;
+            }
 
-			private readonly Array2DHashSet<T> _enclosing;
-		}
-	}
+            private readonly Array2DHashSet<T> _enclosing;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/DoubleKeyMap`3.cs b/Antlr4.Runtime/Misc/DoubleKeyMap`3.cs
index 6e4e5ef47..aaee917c6 100644
--- a/Antlr4.Runtime/Misc/DoubleKeyMap`3.cs
+++ b/Antlr4.Runtime/Misc/DoubleKeyMap`3.cs
@@ -33,76 +33,76 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>Sometimes we need to map a key to a value but key is two pieces of data.
-	/// 	</summary>
-	/// <remarks>
-	/// Sometimes we need to map a key to a value but key is two pieces of data.
-	/// This nested hash table saves creating a single key each time we access
-	/// map; avoids mem creation.
-	/// </remarks>
-	public class DoubleKeyMap<Key1, Key2, Value>
-	{
-		internal IDictionary<Key1, IDictionary<Key2, Value>> data = new LinkedHashMap<Key1
-			, IDictionary<Key2, Value>>();
+    /// <summary>Sometimes we need to map a key to a value but key is two pieces of data.
+    ///     </summary>
+    /// <remarks>
+    /// Sometimes we need to map a key to a value but key is two pieces of data.
+    /// This nested hash table saves creating a single key each time we access
+    /// map; avoids mem creation.
+    /// </remarks>
+    public class DoubleKeyMap<Key1, Key2, Value>
+    {
+        internal IDictionary<Key1, IDictionary<Key2, Value>> data = new LinkedHashMap<Key1
+            , IDictionary<Key2, Value>>();
 
-		public virtual Value Put(Key1 k1, Key2 k2, Value v)
-		{
-			IDictionary<Key2, Value> data2 = data.Get(k1);
-			Value prev = null;
-			if (data2 == null)
-			{
-				data2 = new LinkedHashMap<Key2, Value>();
-				data.Put(k1, data2);
-			}
-			else
-			{
-				prev = data2.Get(k2);
-			}
-			data2.Put(k2, v);
-			return prev;
-		}
+        public virtual Value Put(Key1 k1, Key2 k2, Value v)
+        {
+            IDictionary<Key2, Value> data2 = data.Get(k1);
+            Value prev = null;
+            if (data2 == null)
+            {
+                data2 = new LinkedHashMap<Key2, Value>();
+                data.Put(k1, data2);
+            }
+            else
+            {
+                prev = data2.Get(k2);
+            }
+            data2.Put(k2, v);
+            return prev;
+        }
 
-		public virtual Value Get(Key1 k1, Key2 k2)
-		{
-			IDictionary<Key2, Value> data2 = data.Get(k1);
-			if (data2 == null)
-			{
-				return null;
-			}
-			return data2.Get(k2);
-		}
+        public virtual Value Get(Key1 k1, Key2 k2)
+        {
+            IDictionary<Key2, Value> data2 = data.Get(k1);
+            if (data2 == null)
+            {
+                return null;
+            }
+            return data2.Get(k2);
+        }
 
-		public virtual IDictionary<Key2, Value> Get(Key1 k1)
-		{
-			return data.Get(k1);
-		}
+        public virtual IDictionary<Key2, Value> Get(Key1 k1)
+        {
+            return data.Get(k1);
+        }
 
-		/// <summary>Get all values associated with primary key</summary>
-		public virtual ICollection<Value> Values(Key1 k1)
-		{
-			IDictionary<Key2, Value> data2 = data.Get(k1);
-			if (data2 == null)
-			{
-				return null;
-			}
-			return data2.Values;
-		}
+        /// <summary>Get all values associated with primary key</summary>
+        public virtual ICollection<Value> Values(Key1 k1)
+        {
+            IDictionary<Key2, Value> data2 = data.Get(k1);
+            if (data2 == null)
+            {
+                return null;
+            }
+            return data2.Values;
+        }
 
-		/// <summary>get all primary keys</summary>
-		public virtual ICollection<Key1> KeySet()
-		{
-			return data.Keys;
-		}
+        /// <summary>get all primary keys</summary>
+        public virtual ICollection<Key1> KeySet()
+        {
+            return data.Keys;
+        }
 
-		/// <summary>get all secondary keys associated with a primary key</summary>
-		public virtual ICollection<Key2> KeySet(Key1 k1)
-		{
-			IDictionary<Key2, Value> data2 = data.Get(k1);
-			if (data2 == null)
-			{
-				return null;
-			}
-			return data2.Keys;
-		}
-	}
+        /// <summary>get all secondary keys associated with a primary key</summary>
+        public virtual ICollection<Key2> KeySet(Key1 k1)
+        {
+            IDictionary<Key2, Value> data2 = data.Get(k1);
+            if (data2 == null)
+            {
+                return null;
+            }
+            return data2.Keys;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/FlexibleHashMap`2.cs b/Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
index dc16b3237..d14d0b9e7 100644
--- a/Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
+++ b/Antlr4.Runtime/Misc/FlexibleHashMap`2.cs
@@ -35,363 +35,363 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>
-	/// A limited map (many unsupported operations) that lets me use
-	/// varying hashCode/equals.
-	/// </summary>
-	/// <remarks>
-	/// A limited map (many unsupported operations) that lets me use
-	/// varying hashCode/equals.
-	/// </remarks>
-	public class FlexibleHashMap<K, V> : IDictionary<K, V>
-	{
-		public const int InitalCapacity = 16;
+    /// <summary>
+    /// A limited map (many unsupported operations) that lets me use
+    /// varying hashCode/equals.
+    /// </summary>
+    /// <remarks>
+    /// A limited map (many unsupported operations) that lets me use
+    /// varying hashCode/equals.
+    /// </remarks>
+    public class FlexibleHashMap<K, V> : IDictionary<K, V>
+    {
+        public const int InitalCapacity = 16;
 
-		public const int InitalBucketCapacity = 8;
+        public const int InitalBucketCapacity = 8;
 
-		public const double LoadFactor = 0.75;
+        public const double LoadFactor = 0.75;
 
-		public class Entry<K, V>
-		{
-			public readonly K key;
+        public class Entry<K, V>
+        {
+            public readonly K key;
 
-			public V value;
+            public V value;
 
-			public Entry(K key, V value)
-			{
-				// must be power of 2
-				this.key = key;
-				this.value = value;
-			}
+            public Entry(K key, V value)
+            {
+                // must be power of 2
+                this.key = key;
+                this.value = value;
+            }
 
-			public override string ToString()
-			{
-				return key.ToString() + ":" + value.ToString();
-			}
-		}
+            public override string ToString()
+            {
+                return key.ToString() + ":" + value.ToString();
+            }
+        }
 
-		[NotNull]
-		protected internal readonly AbstractEqualityComparator<K> comparator;
+        [NotNull]
+        protected internal readonly AbstractEqualityComparator<K> comparator;
 
-		protected internal List<FlexibleHashMap.Entry<K, V>>[] buckets;
+        protected internal List<FlexibleHashMap.Entry<K, V>>[] buckets;
 
-		/// <summary>How many elements in set</summary>
-		protected internal int n = 0;
+        /// <summary>How many elements in set</summary>
+        protected internal int n = 0;
 
-		protected internal int threshold = (int)(InitalCapacity * LoadFactor);
+        protected internal int threshold = (int)(InitalCapacity * LoadFactor);
 
-		protected internal int currentPrime = 1;
+        protected internal int currentPrime = 1;
 
-		protected internal int initialBucketCapacity = InitalBucketCapacity;
+        protected internal int initialBucketCapacity = InitalBucketCapacity;
 
-		public FlexibleHashMap() : this(null, InitalCapacity, InitalBucketCapacity)
-		{
-		}
+        public FlexibleHashMap() : this(null, InitalCapacity, InitalBucketCapacity)
+        {
+        }
 
-		public FlexibleHashMap(AbstractEqualityComparator<K> comparator) : this(comparator
-			, InitalCapacity, InitalBucketCapacity)
-		{
-		}
+        public FlexibleHashMap(AbstractEqualityComparator<K> comparator) : this(comparator
+            , InitalCapacity, InitalBucketCapacity)
+        {
+        }
 
-		public FlexibleHashMap(AbstractEqualityComparator<K> comparator, int initialCapacity
-			, int initialBucketCapacity)
-		{
-			// when to expand
-			// jump by 4 primes each expand or whatever
-			if (comparator == null)
-			{
-				comparator = ObjectEqualityComparator.Instance;
-			}
-			this.comparator = comparator;
-			this.buckets = CreateEntryListArray(initialBucketCapacity);
-			this.initialBucketCapacity = initialBucketCapacity;
-		}
+        public FlexibleHashMap(AbstractEqualityComparator<K> comparator, int initialCapacity
+            , int initialBucketCapacity)
+        {
+            // when to expand
+            // jump by 4 primes each expand or whatever
+            if (comparator == null)
+            {
+                comparator = ObjectEqualityComparator.Instance;
+            }
+            this.comparator = comparator;
+            this.buckets = CreateEntryListArray(initialBucketCapacity);
+            this.initialBucketCapacity = initialBucketCapacity;
+        }
 
-		private static List<FlexibleHashMap.Entry<K, V>>[] CreateEntryListArray<K, V>(int
-			 length)
-		{
-			List<FlexibleHashMap.Entry<K, V>>[] result = (List<FlexibleHashMap.Entry<K, V>>[]
-				)new List<object>[length];
-			return result;
-		}
+        private static List<FlexibleHashMap.Entry<K, V>>[] CreateEntryListArray<K, V>(int
+             length)
+        {
+            List<FlexibleHashMap.Entry<K, V>>[] result = (List<FlexibleHashMap.Entry<K, V>>[]
+                )new List<object>[length];
+            return result;
+        }
 
-		protected internal virtual int GetBucket(K key)
-		{
-			int hash = comparator.HashCode(key);
-			int b = hash & (buckets.Length - 1);
-			// assumes len is power of 2
-			return b;
-		}
+        protected internal virtual int GetBucket(K key)
+        {
+            int hash = comparator.HashCode(key);
+            int b = hash & (buckets.Length - 1);
+            // assumes len is power of 2
+            return b;
+        }
 
-		public virtual V Get(object key)
-		{
-			K typedKey = (K)key;
-			if (key == null)
-			{
-				return null;
-			}
-			int b = GetBucket(typedKey);
-			List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
-			if (bucket == null)
-			{
-				return null;
-			}
-			// no bucket
-			foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-			{
-				if (comparator.Equals(e.key, typedKey))
-				{
-					return e.value;
-				}
-			}
-			return null;
-		}
+        public virtual V Get(object key)
+        {
+            K typedKey = (K)key;
+            if (key == null)
+            {
+                return null;
+            }
+            int b = GetBucket(typedKey);
+            List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
+            if (bucket == null)
+            {
+                return null;
+            }
+            // no bucket
+            foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+            {
+                if (comparator.Equals(e.key, typedKey))
+                {
+                    return e.value;
+                }
+            }
+            return null;
+        }
 
-		public virtual V Put(K key, V value)
-		{
-			if (key == null)
-			{
-				return null;
-			}
-			if (n > threshold)
-			{
-				Expand();
-			}
-			int b = GetBucket(key);
-			List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
-			if (bucket == null)
-			{
-				bucket = buckets[b] = new List<FlexibleHashMap.Entry<K, V>>();
-			}
-			foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-			{
-				if (comparator.Equals(e.key, key))
-				{
-					V prev = e.value;
-					e.value = value;
-					n++;
-					return prev;
-				}
-			}
-			// not there
-			bucket.AddItem(new FlexibleHashMap.Entry<K, V>(key, value));
-			n++;
-			return null;
-		}
+        public virtual V Put(K key, V value)
+        {
+            if (key == null)
+            {
+                return null;
+            }
+            if (n > threshold)
+            {
+                Expand();
+            }
+            int b = GetBucket(key);
+            List<FlexibleHashMap.Entry<K, V>> bucket = buckets[b];
+            if (bucket == null)
+            {
+                bucket = buckets[b] = new List<FlexibleHashMap.Entry<K, V>>();
+            }
+            foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+            {
+                if (comparator.Equals(e.key, key))
+                {
+                    V prev = e.value;
+                    e.value = value;
+                    n++;
+                    return prev;
+                }
+            }
+            // not there
+            bucket.AddItem(new FlexibleHashMap.Entry<K, V>(key, value));
+            n++;
+            return null;
+        }
 
-		public virtual V Remove(object key)
-		{
-			throw new NotSupportedException();
-		}
+        public virtual V Remove(object key)
+        {
+            throw new NotSupportedException();
+        }
 
-		public virtual void PutAll<_T0>(IDictionary<_T0> m) where _T0:K
-		{
-			throw new NotSupportedException();
-		}
+        public virtual void PutAll<_T0>(IDictionary<_T0> m) where _T0:K
+        {
+            throw new NotSupportedException();
+        }
 
-		public virtual ICollection<K> Keys
-		{
-			get
-			{
-				throw new NotSupportedException();
-			}
-		}
+        public virtual ICollection<K> Keys
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
 
-		public virtual ICollection<V> Values
-		{
-			get
-			{
-				IList<V> a = new List<V>(Count);
-				foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
-				{
-					if (bucket == null)
-					{
-						continue;
-					}
-					foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-					{
-						a.AddItem(e.value);
-					}
-				}
-				return a;
-			}
-		}
+        public virtual ICollection<V> Values
+        {
+            get
+            {
+                IList<V> a = new List<V>(Count);
+                foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+                {
+                    if (bucket == null)
+                    {
+                        continue;
+                    }
+                    foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+                    {
+                        a.AddItem(e.value);
+                    }
+                }
+                return a;
+            }
+        }
 
-		public virtual ICollection<KeyValuePair<K, V>> EntrySet()
-		{
-			throw new NotSupportedException();
-		}
+        public virtual ICollection<KeyValuePair<K, V>> EntrySet()
+        {
+            throw new NotSupportedException();
+        }
 
-		public virtual bool ContainsKey(object key)
-		{
-			return Get(key) != null;
-		}
+        public virtual bool ContainsKey(object key)
+        {
+            return Get(key) != null;
+        }
 
-		public virtual bool ContainsValue(object value)
-		{
-			throw new NotSupportedException();
-		}
+        public virtual bool ContainsValue(object value)
+        {
+            throw new NotSupportedException();
+        }
 
-		public override int GetHashCode()
-		{
-			int h = 0;
-			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-				{
-					if (e == null)
-					{
-						break;
-					}
-					h += comparator.HashCode(e.key);
-				}
-			}
-			return h;
-		}
+        public override int GetHashCode()
+        {
+            int h = 0;
+            foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+                {
+                    if (e == null)
+                    {
+                        break;
+                    }
+                    h += comparator.HashCode(e.key);
+                }
+            }
+            return h;
+        }
 
-		public override bool Equals(object o)
-		{
-			throw new NotSupportedException();
-		}
+        public override bool Equals(object o)
+        {
+            throw new NotSupportedException();
+        }
 
-		protected internal virtual void Expand()
-		{
-			List<FlexibleHashMap.Entry<K, V>>[] old = buckets;
-			currentPrime += 4;
-			int newCapacity = buckets.Length * 2;
-			List<FlexibleHashMap.Entry<K, V>>[] newTable = CreateEntryListArray(newCapacity);
-			buckets = newTable;
-			threshold = (int)(newCapacity * LoadFactor);
-			//		System.out.println("new size="+newCapacity+", thres="+threshold);
-			// rehash all existing entries
-			int oldSize = Count;
-			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in old)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-				{
-					if (e == null)
-					{
-						break;
-					}
-					Put(e.key, e.value);
-				}
-			}
-			n = oldSize;
-		}
+        protected internal virtual void Expand()
+        {
+            List<FlexibleHashMap.Entry<K, V>>[] old = buckets;
+            currentPrime += 4;
+            int newCapacity = buckets.Length * 2;
+            List<FlexibleHashMap.Entry<K, V>>[] newTable = CreateEntryListArray(newCapacity);
+            buckets = newTable;
+            threshold = (int)(newCapacity * LoadFactor);
+            //		System.out.println("new size="+newCapacity+", thres="+threshold);
+            // rehash all existing entries
+            int oldSize = Count;
+            foreach (List<FlexibleHashMap.Entry<K, V>> bucket in old)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+                {
+                    if (e == null)
+                    {
+                        break;
+                    }
+                    Put(e.key, e.value);
+                }
+            }
+            n = oldSize;
+        }
 
-		public virtual int Count
-		{
-			get
-			{
-				return n;
-			}
-		}
+        public virtual int Count
+        {
+            get
+            {
+                return n;
+            }
+        }
 
-		public virtual bool IsEmpty()
-		{
-			return n == 0;
-		}
+        public virtual bool IsEmpty()
+        {
+            return n == 0;
+        }
 
-		public virtual void Clear()
-		{
-			buckets = CreateEntryListArray(InitalCapacity);
-			n = 0;
-		}
+        public virtual void Clear()
+        {
+            buckets = CreateEntryListArray(InitalCapacity);
+            n = 0;
+        }
 
-		public override string ToString()
-		{
-			if (Count == 0)
-			{
-				return "{}";
-			}
-			StringBuilder buf = new StringBuilder();
-			buf.Append('{');
-			bool first = true;
-			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					continue;
-				}
-				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-				{
-					if (e == null)
-					{
-						break;
-					}
-					if (first)
-					{
-						first = false;
-					}
-					else
-					{
-						buf.Append(", ");
-					}
-					buf.Append(e.ToString());
-				}
-			}
-			buf.Append('}');
-			return buf.ToString();
-		}
+        public override string ToString()
+        {
+            if (Count == 0)
+            {
+                return "{}";
+            }
+            StringBuilder buf = new StringBuilder();
+            buf.Append('{');
+            bool first = true;
+            foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    continue;
+                }
+                foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+                {
+                    if (e == null)
+                    {
+                        break;
+                    }
+                    if (first)
+                    {
+                        first = false;
+                    }
+                    else
+                    {
+                        buf.Append(", ");
+                    }
+                    buf.Append(e.ToString());
+                }
+            }
+            buf.Append('}');
+            return buf.ToString();
+        }
 
-		public virtual string ToTableString()
-		{
-			StringBuilder buf = new StringBuilder();
-			foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
-			{
-				if (bucket == null)
-				{
-					buf.Append("null\n");
-					continue;
-				}
-				buf.Append('[');
-				bool first = true;
-				foreach (FlexibleHashMap.Entry<K, V> e in bucket)
-				{
-					if (first)
-					{
-						first = false;
-					}
-					else
-					{
-						buf.Append(" ");
-					}
-					if (e == null)
-					{
-						buf.Append("_");
-					}
-					else
-					{
-						buf.Append(e.ToString());
-					}
-				}
-				buf.Append("]\n");
-			}
-			return buf.ToString();
-		}
+        public virtual string ToTableString()
+        {
+            StringBuilder buf = new StringBuilder();
+            foreach (List<FlexibleHashMap.Entry<K, V>> bucket in buckets)
+            {
+                if (bucket == null)
+                {
+                    buf.Append("null\n");
+                    continue;
+                }
+                buf.Append('[');
+                bool first = true;
+                foreach (FlexibleHashMap.Entry<K, V> e in bucket)
+                {
+                    if (first)
+                    {
+                        first = false;
+                    }
+                    else
+                    {
+                        buf.Append(" ");
+                    }
+                    if (e == null)
+                    {
+                        buf.Append("_");
+                    }
+                    else
+                    {
+                        buf.Append(e.ToString());
+                    }
+                }
+                buf.Append("]\n");
+            }
+            return buf.ToString();
+        }
 
-		public static void Main(string[] args)
-		{
-			FlexibleHashMap<string, int> map = new FlexibleHashMap<string, int>();
-			map.Put("hi", 1);
-			map.Put("mom", 2);
-			map.Put("foo", 3);
-			map.Put("ach", 4);
-			map.Put("cbba", 5);
-			map.Put("d", 6);
-			map.Put("edf", 7);
-			map.Put("mom", 8);
-			map.Put("hi", 9);
-			System.Console.Out.WriteLine(map);
-			System.Console.Out.WriteLine(map.ToTableString());
-		}
-	}
+        public static void Main(string[] args)
+        {
+            FlexibleHashMap<string, int> map = new FlexibleHashMap<string, int>();
+            map.Put("hi", 1);
+            map.Put("mom", 2);
+            map.Put("foo", 3);
+            map.Put("ach", 4);
+            map.Put("cbba", 5);
+            map.Put("d", 6);
+            map.Put("edf", 7);
+            map.Put("mom", 8);
+            map.Put("hi", 9);
+            System.Console.Out.WriteLine(map);
+            System.Console.Out.WriteLine(map.ToTableString());
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/IFunc0`1.cs b/Antlr4.Runtime/Misc/IFunc0`1.cs
index 3088e14c4..dfb936cbc 100644
--- a/Antlr4.Runtime/Misc/IFunc0`1.cs
+++ b/Antlr4.Runtime/Misc/IFunc0`1.cs
@@ -32,9 +32,9 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <author>Sam Harwell</author>
-	public interface IFunc0<Result>
-	{
-		Result Eval();
-	}
+    /// <author>Sam Harwell</author>
+    public interface IFunc0<Result>
+    {
+        Result Eval();
+    }
 }
diff --git a/Antlr4.Runtime/Misc/IFunc1`2.cs b/Antlr4.Runtime/Misc/IFunc1`2.cs
index fa3b371c8..3270592f1 100644
--- a/Antlr4.Runtime/Misc/IFunc1`2.cs
+++ b/Antlr4.Runtime/Misc/IFunc1`2.cs
@@ -32,9 +32,9 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <author>Sam Harwell</author>
-	public interface IFunc1<T1, Result>
-	{
-		Result Eval(T1 arg1);
-	}
+    /// <author>Sam Harwell</author>
+    public interface IFunc1<T1, Result>
+    {
+        Result Eval(T1 arg1);
+    }
 }
diff --git a/Antlr4.Runtime/Misc/IIntSet.cs b/Antlr4.Runtime/Misc/IIntSet.cs
index 2662fb147..a8aa5bf40 100644
--- a/Antlr4.Runtime/Misc/IIntSet.cs
+++ b/Antlr4.Runtime/Misc/IIntSet.cs
@@ -33,60 +33,60 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>A generic set of ints.</summary>
-	/// <remarks>A generic set of ints.</remarks>
-	/// <seealso cref="IntervalSet">IntervalSet</seealso>
-	public interface IIntSet
-	{
-		/// <summary>Add an element to the set</summary>
-		void Add(int el);
+    /// <summary>A generic set of ints.</summary>
+    /// <remarks>A generic set of ints.</remarks>
+    /// <seealso cref="IntervalSet">IntervalSet</seealso>
+    public interface IIntSet
+    {
+        /// <summary>Add an element to the set</summary>
+        void Add(int el);
 
-		/// <summary>Add all elements from incoming set to this set.</summary>
-		/// <remarks>
-		/// Add all elements from incoming set to this set.  Can limit
-		/// to set of its own type. Return "this" so we can chain calls.
-		/// </remarks>
-		IIntSet AddAll(IIntSet set);
+        /// <summary>Add all elements from incoming set to this set.</summary>
+        /// <remarks>
+        /// Add all elements from incoming set to this set.  Can limit
+        /// to set of its own type. Return "this" so we can chain calls.
+        /// </remarks>
+        IIntSet AddAll(IIntSet set);
 
-		/// <summary>
-		/// Return the intersection of this set with the argument, creating
-		/// a new set.
-		/// </summary>
-		/// <remarks>
-		/// Return the intersection of this set with the argument, creating
-		/// a new set.
-		/// </remarks>
-		IIntSet And(IIntSet a);
+        /// <summary>
+        /// Return the intersection of this set with the argument, creating
+        /// a new set.
+        /// </summary>
+        /// <remarks>
+        /// Return the intersection of this set with the argument, creating
+        /// a new set.
+        /// </remarks>
+        IIntSet And(IIntSet a);
 
-		IIntSet Complement(IIntSet elements);
+        IIntSet Complement(IIntSet elements);
 
-		IIntSet Or(IIntSet a);
+        IIntSet Or(IIntSet a);
 
-		IIntSet Subtract(IIntSet a);
+        IIntSet Subtract(IIntSet a);
 
-		/// <summary>
-		/// Return the size of this set (not the underlying implementation's
-		/// allocated memory size, for example).
-		/// </summary>
-		/// <remarks>
-		/// Return the size of this set (not the underlying implementation's
-		/// allocated memory size, for example).
-		/// </remarks>
-		int Size();
+        /// <summary>
+        /// Return the size of this set (not the underlying implementation's
+        /// allocated memory size, for example).
+        /// </summary>
+        /// <remarks>
+        /// Return the size of this set (not the underlying implementation's
+        /// allocated memory size, for example).
+        /// </remarks>
+        int Size();
 
-		bool IsNil();
+        bool IsNil();
 
-		bool Equals(object obj);
+        bool Equals(object obj);
 
-		int GetSingleElement();
+        int GetSingleElement();
 
-		bool Contains(int el);
+        bool Contains(int el);
 
-		/// <summary>remove this element from this set</summary>
-		void Remove(int el);
+        /// <summary>remove this element from this set</summary>
+        void Remove(int el);
 
-		IList<int> ToList();
+        IList<int> ToList();
 
-		string ToString();
-	}
+        string ToString();
+    }
 }
diff --git a/Antlr4.Runtime/Misc/IPredicate`1.cs b/Antlr4.Runtime/Misc/IPredicate`1.cs
index b2ee45710..5352d8069 100644
--- a/Antlr4.Runtime/Misc/IPredicate`1.cs
+++ b/Antlr4.Runtime/Misc/IPredicate`1.cs
@@ -32,9 +32,9 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <author>Sam Harwell</author>
-	public interface IPredicate<T>
-	{
-		bool Eval(T arg);
-	}
+    /// <author>Sam Harwell</author>
+    public interface IPredicate<T>
+    {
+        bool Eval(T arg);
+    }
 }
diff --git a/Antlr4.Runtime/Misc/Interval.cs b/Antlr4.Runtime/Misc/Interval.cs
index 2308206ef..3be6581a3 100644
--- a/Antlr4.Runtime/Misc/Interval.cs
+++ b/Antlr4.Runtime/Misc/Interval.cs
@@ -32,195 +32,195 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>An immutable inclusive interval a..b</summary>
-	public class Interval
-	{
-		public const int IntervalPoolMaxValue = 1000;
+    /// <summary>An immutable inclusive interval a..b</summary>
+    public class Interval
+    {
+        public const int IntervalPoolMaxValue = 1000;
 
-		public static readonly Antlr4.Runtime.Misc.Interval Invalid = new Antlr4.Runtime.Misc.Interval
-			(-1, -2);
+        public static readonly Antlr4.Runtime.Misc.Interval Invalid = new Antlr4.Runtime.Misc.Interval
+            (-1, -2);
 
-		private static Antlr4.Runtime.Misc.Interval[] cache = new Antlr4.Runtime.Misc.Interval
-			[IntervalPoolMaxValue + 1];
+        private static Antlr4.Runtime.Misc.Interval[] cache = new Antlr4.Runtime.Misc.Interval
+            [IntervalPoolMaxValue + 1];
 
-		/// <summary>The start of the interval.</summary>
-		/// <remarks>The start of the interval.</remarks>
-		public readonly int a;
+        /// <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;
+        /// <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;
-		}
+        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)
-		{
-			// cache just a..a
-			if (a != b || a < 0 || a > IntervalPoolMaxValue)
-			{
-				return new Antlr4.Runtime.Misc.Interval(a, b);
-			}
-			if (cache[a] == null)
-			{
-				cache[a] = new Antlr4.Runtime.Misc.Interval(a, a);
-			}
-			return cache[a];
-		}
+        /// <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)
+        {
+            // cache just a..a
+            if (a != b || a < 0 || a > IntervalPoolMaxValue)
+            {
+                return new Antlr4.Runtime.Misc.Interval(a, b);
+            }
+            if (cache[a] == null)
+            {
+                cache[a] = new Antlr4.Runtime.Misc.Interval(a, a);
+            }
+            return cache[a];
+        }
 
-		/// <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 virtual int Length()
-		{
-			if (b < a)
-			{
-				return 0;
-			}
-			return b - a + 1;
-		}
+        /// <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 virtual int Length()
+        {
+            if (b < a)
+            {
+                return 0;
+            }
+            return b - a + 1;
+        }
 
-		public override bool Equals(object o)
-		{
-			if (o == this)
-			{
-				return true;
-			}
-			else
-			{
-				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 bool Equals(object o)
+        {
+            if (o == this)
+            {
+                return true;
+            }
+            else
+            {
+                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 = 5;
-			hash = 37 * hash ^ this.a;
-			hash = 37 * hash ^ this.b;
-			return hash;
-		}
+        public override int GetHashCode()
+        {
+            int hash = 5;
+            hash = 37 * hash ^ this.a;
+            hash = 37 * hash ^ this.b;
+            return hash;
+        }
 
-		/// <summary>Does this start completely before other? Disjoint</summary>
-		public virtual bool StartsBeforeDisjoint(Antlr4.Runtime.Misc.Interval other)
-		{
-			return this.a < other.a && this.b < other.a;
-		}
+        /// <summary>Does this start completely before other? Disjoint</summary>
+        public virtual 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 virtual bool StartsBeforeNonDisjoint(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 virtual 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 virtual bool StartsAfter(Antlr4.Runtime.Misc.Interval other)
-		{
-			return this.a > other.a;
-		}
+        /// <summary>Does this.a start after other.b? May or may not be disjoint</summary>
+        public virtual bool StartsAfter(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a > other.a;
+        }
 
-		/// <summary>Does this start completely after other? Disjoint</summary>
-		public virtual bool StartsAfterDisjoint(Antlr4.Runtime.Misc.Interval other)
-		{
-			return this.a > other.b;
-		}
+        /// <summary>Does this start completely after other? Disjoint</summary>
+        public virtual bool StartsAfterDisjoint(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a > other.b;
+        }
 
-		/// <summary>Does this start after other? NonDisjoint</summary>
-		public virtual bool StartsAfterNonDisjoint(Antlr4.Runtime.Misc.Interval other)
-		{
-			return this.a > other.a && this.a <= other.b;
-		}
+        /// <summary>Does this start after other? NonDisjoint</summary>
+        public virtual 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 virtual bool Disjoint(Antlr4.Runtime.Misc.Interval other)
-		{
-			return StartsBeforeDisjoint(other) || StartsAfterDisjoint(other);
-		}
+        // this.b>=other.b implied
+        /// <summary>Are both ranges disjoint? I.e., no overlap?</summary>
+        public virtual 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 virtual bool Adjacent(Antlr4.Runtime.Misc.Interval other)
-		{
-			return this.a == other.b + 1 || this.b == other.a - 1;
-		}
+        /// <summary>Are two intervals adjacent such as 0..41 and 42..42?</summary>
+        public virtual bool Adjacent(Antlr4.Runtime.Misc.Interval other)
+        {
+            return this.a == other.b + 1 || this.b == other.a - 1;
+        }
 
-		public virtual bool ProperlyContains(Antlr4.Runtime.Misc.Interval other)
-		{
-			return other.a >= this.a && other.b <= this.b;
-		}
+        public virtual 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 virtual 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 computed from combining this and other</summary>
+        public virtual 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 virtual 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 in common between this and o</summary>
+        public virtual 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
-		/// <code>this</code>
-		/// not in
-		/// <code>other</code>
-		/// ;
-		/// <code>other</code>
-		/// must not be totally enclosed (properly contained)
-		/// within
-		/// <code>this</code>
-		/// , which would result in two disjoint intervals
-		/// instead of the single one returned by this method.
-		/// </summary>
-		public virtual 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;
-		}
+        /// <summary>
+        /// Return the interval with elements from
+        /// <code>this</code>
+        /// not in
+        /// <code>other</code>
+        /// ;
+        /// <code>other</code>
+        /// must not be totally enclosed (properly contained)
+        /// within
+        /// <code>this</code>
+        /// , which would result in two disjoint intervals
+        /// instead of the single one returned by this method.
+        /// </summary>
+        public virtual 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;
-		}
-	}
+        public override string ToString()
+        {
+            return a + ".." + b;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/IntervalSet.cs b/Antlr4.Runtime/Misc/IntervalSet.cs
index b0e3961e5..b4283099c 100644
--- a/Antlr4.Runtime/Misc/IntervalSet.cs
+++ b/Antlr4.Runtime/Misc/IntervalSet.cs
@@ -36,786 +36,786 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>
-	/// 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).
-	/// </summary>
-	/// <remarks>
-	/// 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.
-	/// 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.
-	/// </remarks>
-	public class IntervalSet : IIntSet
-	{
-		public static readonly Antlr4.Runtime.Misc.IntervalSet CompleteCharSet = Antlr4.Runtime.Misc.IntervalSet
-			.Of(0, Lexer.MaxCharValue);
+    /// <summary>
+    /// 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).
+    /// </summary>
+    /// <remarks>
+    /// 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.
+    /// 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.
+    /// </remarks>
+    public class IntervalSet : IIntSet
+    {
+        public static readonly Antlr4.Runtime.Misc.IntervalSet CompleteCharSet = Antlr4.Runtime.Misc.IntervalSet
+            .Of(0, Lexer.MaxCharValue);
 
-		public static readonly Antlr4.Runtime.Misc.IntervalSet EmptySet = new Antlr4.Runtime.Misc.IntervalSet
-			();
+        public static readonly Antlr4.Runtime.Misc.IntervalSet EmptySet = new Antlr4.Runtime.Misc.IntervalSet
+            ();
 
-		/// <summary>The list of sorted, disjoint intervals.</summary>
-		/// <remarks>The list of sorted, disjoint intervals.</remarks>
-		protected internal IList<Interval> intervals;
+        /// <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;
+        protected internal bool @readonly;
 
-		public IntervalSet(IList<Interval> intervals)
-		{
-			this.intervals = intervals;
-		}
+        public IntervalSet(IList<Interval> intervals)
+        {
+            this.intervals = intervals;
+        }
 
-		public IntervalSet(Antlr4.Runtime.Misc.IntervalSet set) : this()
-		{
-			AddAll(set);
-		}
+        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);
-				}
-			}
-		}
+        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>
-		[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 a single element, el.</summary>
+        /// <remarks>Create a set with a single element, el.</remarks>
+        [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;
-		}
+        /// <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();
-		}
+        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 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));
-		}
+        /// <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 (IListIterator<Interval> iter = intervals.ListIterator(); iter.HasNext(); )
-			{
-				Interval r = iter.Next();
-				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);
-					iter.Set(bigger);
-					// make sure we didn't just create an interval that
-					// should be merged with next interval in list
-					if (iter.HasNext())
-					{
-						Interval next = iter.Next();
-						if (bigger.Adjacent(next) || !bigger.Disjoint(next))
-						{
-							// if we bump up against or overlap next, merge
-							iter.Remove();
-							// remove this one
-							iter.Previous();
-							// move backwards to what we just set
-							iter.Set(bigger.Union(next));
-						}
-					}
-					// set to 3 merged ones
-					return;
-				}
-				if (addition.StartsBeforeDisjoint(r))
-				{
-					// insert before r
-					iter.Previous();
-					iter.Add(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.AddItem(addition);
-		}
+        // 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 (IListIterator<Interval> iter = intervals.ListIterator(); iter.HasNext(); )
+            {
+                Interval r = iter.Next();
+                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);
+                    iter.Set(bigger);
+                    // make sure we didn't just create an interval that
+                    // should be merged with next interval in list
+                    if (iter.HasNext())
+                    {
+                        Interval next = iter.Next();
+                        if (bigger.Adjacent(next) || !bigger.Disjoint(next))
+                        {
+                            // if we bump up against or overlap next, merge
+                            iter.Remove();
+                            // remove this one
+                            iter.Previous();
+                            // move backwards to what we just set
+                            iter.Set(bigger.Union(next));
+                        }
+                    }
+                    // set to 3 merged ones
+                    return;
+                }
+                if (addition.StartsBeforeDisjoint(r))
+                {
+                    // insert before r
+                    iter.Previous();
+                    iter.Add(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.AddItem(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;
-		}
+        /// <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))
-			{
-				throw new ArgumentException("can't add non IntSet (" + set.GetType().FullName + ") to 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);
-			}
-			return this;
-		}
+        public virtual Antlr4.Runtime.Misc.IntervalSet AddAll(IIntSet set)
+        {
+            if (set == null)
+            {
+                return this;
+            }
+            if (!(set is Antlr4.Runtime.Misc.IntervalSet))
+            {
+                throw new ArgumentException("can't add non IntSet (" + set.GetType().FullName + ") to 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);
+            }
+            return this;
+        }
 
-		public virtual Antlr4.Runtime.Misc.IntervalSet Complement(int minElement, int maxElement
-			)
-		{
-			return this.Complement(Antlr4.Runtime.Misc.IntervalSet.Of(minElement, maxElement)
-				);
-		}
+        public virtual Antlr4.Runtime.Misc.IntervalSet Complement(int minElement, int maxElement
+            )
+        {
+            return this.Complement(Antlr4.Runtime.Misc.IntervalSet.Of(minElement, maxElement)
+                );
+        }
 
-		/// <summary>
-		/// 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.
-		/// </summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		public virtual Antlr4.Runtime.Misc.IntervalSet Complement(IIntSet vocabulary)
-		{
-			if (vocabulary == null)
-			{
-				return null;
-			}
-			// nothing in common with null set
-			if (!(vocabulary is Antlr4.Runtime.Misc.IntervalSet))
-			{
-				throw new ArgumentException("can't complement with non IntervalSet (" + vocabulary
-					.GetType().FullName + ")");
-			}
-			Antlr4.Runtime.Misc.IntervalSet vocabularyIS = ((Antlr4.Runtime.Misc.IntervalSet)
-				vocabulary);
-			int maxElement = vocabularyIS.GetMaxElement();
-			Antlr4.Runtime.Misc.IntervalSet compl = new Antlr4.Runtime.Misc.IntervalSet();
-			int n = intervals.Count;
-			if (n == 0)
-			{
-				return compl;
-			}
-			Interval first = intervals[0];
-			// add a range from 0 to first.a constrained to vocab
-			if (first.a > 0)
-			{
-				Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(0, first.a
-					 - 1);
-				Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
-				compl.AddAll(a);
-			}
-			for (int i = 1; i < n; i++)
-			{
-				// from 2nd interval .. nth
-				Interval previous = intervals[i - 1];
-				Interval current = intervals[i];
-				Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(previous.b
-					 + 1, current.a - 1);
-				Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
-				compl.AddAll(a);
-			}
-			Interval last = intervals[n - 1];
-			// add a range from last.b to maxElement constrained to vocab
-			if (last.b < maxElement)
-			{
-				Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(last.b + 1
-					, maxElement);
-				Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
-				compl.AddAll(a);
-			}
-			return compl;
-		}
+        /// <summary>
+        /// 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.
+        /// </summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        public virtual Antlr4.Runtime.Misc.IntervalSet Complement(IIntSet vocabulary)
+        {
+            if (vocabulary == null)
+            {
+                return null;
+            }
+            // nothing in common with null set
+            if (!(vocabulary is Antlr4.Runtime.Misc.IntervalSet))
+            {
+                throw new ArgumentException("can't complement with non IntervalSet (" + vocabulary
+                    .GetType().FullName + ")");
+            }
+            Antlr4.Runtime.Misc.IntervalSet vocabularyIS = ((Antlr4.Runtime.Misc.IntervalSet)
+                vocabulary);
+            int maxElement = vocabularyIS.GetMaxElement();
+            Antlr4.Runtime.Misc.IntervalSet compl = new Antlr4.Runtime.Misc.IntervalSet();
+            int n = intervals.Count;
+            if (n == 0)
+            {
+                return compl;
+            }
+            Interval first = intervals[0];
+            // add a range from 0 to first.a constrained to vocab
+            if (first.a > 0)
+            {
+                Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(0, first.a
+                     - 1);
+                Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
+                compl.AddAll(a);
+            }
+            for (int i = 1; i < n; i++)
+            {
+                // from 2nd interval .. nth
+                Interval previous = intervals[i - 1];
+                Interval current = intervals[i];
+                Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(previous.b
+                     + 1, current.a - 1);
+                Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
+                compl.AddAll(a);
+            }
+            Interval last = intervals[n - 1];
+            // add a range from last.b to maxElement constrained to vocab
+            if (last.b < maxElement)
+            {
+                Antlr4.Runtime.Misc.IntervalSet s = Antlr4.Runtime.Misc.IntervalSet.Of(last.b + 1
+                    , maxElement);
+                Antlr4.Runtime.Misc.IntervalSet a = s.And(vocabularyIS);
+                compl.AddAll(a);
+            }
+            return compl;
+        }
 
-		/// <summary>Compute this-other via this&~other.</summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet 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(((Antlr4.Runtime.Misc.IntervalSet)other).Complement(CompleteCharSet
-				));
-		}
+        /// <summary>Compute this-other via this&~other.</summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        public virtual Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet 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(((Antlr4.Runtime.Misc.IntervalSet)other).Complement(CompleteCharSet
+                ));
+        }
 
-		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;
-		}
+        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>Return a new set with the intersection of this set with other.</summary>
-		/// <remarks>
-		/// 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.
-		/// </remarks>
-		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>Return a new set with the intersection of this set with other.</summary>
+        /// <remarks>
+        /// 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.
+        /// </remarks>
+        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>Is el in any range of this set?</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>Is el in any range of this set?</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>return true if this set has no members</summary>
-		public virtual bool IsNil()
-		{
-			return intervals == null || intervals.IsEmpty();
-		}
+        /// <summary>return true if this set has no members</summary>
+        public virtual bool IsNil()
+        {
+            return intervals == null || intervals.IsEmpty();
+        }
 
-		/// <summary>If this set is a single integer, return it otherwise Token.INVALID_TYPE</summary>
-		public virtual int GetSingleElement()
-		{
-			if (intervals != null && intervals.Count == 1)
-			{
-				Interval I = intervals[0];
-				if (I.a == I.b)
-				{
-					return I.a;
-				}
-			}
-			return IToken.InvalidType;
-		}
+        /// <summary>If this set is a single integer, return it otherwise Token.INVALID_TYPE</summary>
+        public virtual int GetSingleElement()
+        {
+            if (intervals != null && intervals.Count == 1)
+            {
+                Interval I = intervals[0];
+                if (I.a == I.b)
+                {
+                    return I.a;
+                }
+            }
+            return IToken.InvalidType;
+        }
 
-		public virtual int GetMaxElement()
-		{
-			if (IsNil())
-			{
-				return IToken.InvalidType;
-			}
-			Interval last = intervals[intervals.Count - 1];
-			return last.b;
-		}
+        public virtual int GetMaxElement()
+        {
+            if (IsNil())
+            {
+                return IToken.InvalidType;
+            }
+            Interval last = intervals[intervals.Count - 1];
+            return last.b;
+        }
 
-		/// <summary>Return minimum element &gt;= 0</summary>
-		public virtual int GetMinElement()
-		{
-			if (IsNil())
-			{
-				return IToken.InvalidType;
-			}
-			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++)
-				{
-					if (v >= 0)
-					{
-						return v;
-					}
-				}
-			}
-			return IToken.InvalidType;
-		}
+        /// <summary>Return minimum element &gt;= 0</summary>
+        public virtual int GetMinElement()
+        {
+            if (IsNil())
+            {
+                return IToken.InvalidType;
+            }
+            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++)
+                {
+                    if (v >= 0)
+                    {
+                        return v;
+                    }
+                }
+            }
+            return IToken.InvalidType;
+        }
 
-		/// <summary>Return a list of Interval objects.</summary>
-		/// <remarks>Return a list of Interval objects.</remarks>
-		public virtual IList<Interval> GetIntervals()
-		{
-			return intervals;
-		}
+        /// <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()
-		{
-			if (IsNil())
-			{
-				return 0;
-			}
-			int n = 0;
-			// just add left edge of intervals
-			foreach (Interval I in intervals)
-			{
-				n += I.a;
-			}
-			return n;
-		}
+        public override int GetHashCode()
+        {
+            if (IsNil())
+            {
+                return 0;
+            }
+            int n = 0;
+            // just add left edge of intervals
+            foreach (Interval I in intervals)
+            {
+                n += I.a;
+            }
+            return n;
+        }
 
-		/// <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.Equals(other.intervals);
-		}
+        /// <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.Equals(other.intervals);
+        }
 
-		public override string ToString()
-		{
-			return ToString(false);
-		}
+        public override string ToString()
+        {
+            return ToString(false);
+        }
 
-		public virtual string ToString(bool elemAreChar)
-		{
-			StringBuilder buf = new StringBuilder();
-			if (this.intervals == null || this.intervals.IsEmpty())
-			{
-				return "{}";
-			}
-			if (this.Size() > 1)
-			{
-				buf.Append("{");
-			}
-			IEnumerator<Interval> iter = this.intervals.GetEnumerator();
-			while (iter.HasNext())
-			{
-				Interval I = iter.Next();
-				int a = I.a;
-				int b = I.b;
-				if (a == b)
-				{
-					if (a == -1)
-					{
-						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 (iter.HasNext())
-				{
-					buf.Append(", ");
-				}
-			}
-			if (this.Size() > 1)
-			{
-				buf.Append("}");
-			}
-			return buf.ToString();
-		}
+        public virtual string ToString(bool elemAreChar)
+        {
+            StringBuilder buf = new StringBuilder();
+            if (this.intervals == null || this.intervals.IsEmpty())
+            {
+                return "{}";
+            }
+            if (this.Size() > 1)
+            {
+                buf.Append("{");
+            }
+            IEnumerator<Interval> iter = this.intervals.GetEnumerator();
+            while (iter.HasNext())
+            {
+                Interval I = iter.Next();
+                int a = I.a;
+                int b = I.b;
+                if (a == b)
+                {
+                    if (a == -1)
+                    {
+                        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 (iter.HasNext())
+                {
+                    buf.Append(", ");
+                }
+            }
+            if (this.Size() > 1)
+            {
+                buf.Append("}");
+            }
+            return buf.ToString();
+        }
 
-		public virtual string ToString(string[] tokenNames)
-		{
-			StringBuilder buf = new StringBuilder();
-			if (this.intervals == null || this.intervals.IsEmpty())
-			{
-				return "{}";
-			}
-			if (this.Size() > 1)
-			{
-				buf.Append("{");
-			}
-			IEnumerator<Interval> iter = this.intervals.GetEnumerator();
-			while (iter.HasNext())
-			{
-				Interval I = iter.Next();
-				int a = I.a;
-				int b = I.b;
-				if (a == b)
-				{
-					buf.Append(ElementName(tokenNames, a));
-				}
-				else
-				{
-					for (int i = a; i <= b; i++)
-					{
-						if (i > a)
-						{
-							buf.Append(", ");
-						}
-						buf.Append(ElementName(tokenNames, i));
-					}
-				}
-				if (iter.HasNext())
-				{
-					buf.Append(", ");
-				}
-			}
-			if (this.Size() > 1)
-			{
-				buf.Append("}");
-			}
-			return buf.ToString();
-		}
+        public virtual string ToString(string[] tokenNames)
+        {
+            StringBuilder buf = new StringBuilder();
+            if (this.intervals == null || this.intervals.IsEmpty())
+            {
+                return "{}";
+            }
+            if (this.Size() > 1)
+            {
+                buf.Append("{");
+            }
+            IEnumerator<Interval> iter = this.intervals.GetEnumerator();
+            while (iter.HasNext())
+            {
+                Interval I = iter.Next();
+                int a = I.a;
+                int b = I.b;
+                if (a == b)
+                {
+                    buf.Append(ElementName(tokenNames, a));
+                }
+                else
+                {
+                    for (int i = a; i <= b; i++)
+                    {
+                        if (i > a)
+                        {
+                            buf.Append(", ");
+                        }
+                        buf.Append(ElementName(tokenNames, i));
+                    }
+                }
+                if (iter.HasNext())
+                {
+                    buf.Append(", ");
+                }
+            }
+            if (this.Size() > 1)
+            {
+                buf.Append("}");
+            }
+            return buf.ToString();
+        }
 
-		protected internal virtual string ElementName(string[] tokenNames, int a)
-		{
-			if (a == IToken.Eof)
-			{
-				return "<EOF>";
-			}
-			else
-			{
-				if (a == IToken.Epsilon)
-				{
-					return "<EPSILON>";
-				}
-				else
-				{
-					return tokenNames[a];
-				}
-			}
-		}
+        protected internal virtual string ElementName(string[] tokenNames, int a)
+        {
+            if (a == IToken.Eof)
+            {
+                return "<EOF>";
+            }
+            else
+            {
+                if (a == IToken.Epsilon)
+                {
+                    return "<EPSILON>";
+                }
+                else
+                {
+                    return tokenNames[a];
+                }
+            }
+        }
 
-		public virtual int Size()
-		{
-			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 int Size()
+        {
+            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 IntegerList ToIntegerList()
-		{
-			IntegerList values = new IntegerList(Size());
-			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 IntegerList ToIntegerList()
+        {
+            IntegerList values = new IntegerList(Size());
+            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.AddItem(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.AddItem(v);
+                }
+            }
+            return values;
+        }
 
-		public virtual ICollection<int> ToSet()
-		{
-			ICollection<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.AddItem(v);
-				}
-			}
-			return s;
-		}
+        public virtual ICollection<int> ToSet()
+        {
+            ICollection<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.AddItem(v);
+                }
+            }
+            return s;
+        }
 
-		public virtual int[] ToArray()
-		{
-			return ToIntegerList().ToArray();
-		}
+        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.Remove(i);
-					break;
-				}
-				// if on left edge x..b, adjust left
-				if (el == a)
-				{
-					intervals.Set(i, Interval.Of(I.a + 1, I.b));
-					break;
-				}
-				// if on right edge a..x, adjust right
-				if (el == b)
-				{
-					intervals.Set(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.Set(i, Interval.Of(I.a, el - 1));
-					// [a..x-1]
-					Add(el + 1, oldb);
-				}
-			}
-		}
+        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.Remove(i);
+                    break;
+                }
+                // if on left edge x..b, adjust left
+                if (el == a)
+                {
+                    intervals.Set(i, Interval.Of(I.a + 1, I.b));
+                    break;
+                }
+                // if on right edge a..x, adjust right
+                if (el == b)
+                {
+                    intervals.Set(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.Set(i, Interval.Of(I.a, el - 1));
+                    // [a..x-1]
+                    Add(el + 1, oldb);
+                }
+            }
+        }
 
-		// add [x+1..b]
-		public virtual bool IsReadonly()
-		{
-			return @readonly;
-		}
+        // add [x+1..b]
+        public virtual bool IsReadonly()
+        {
+            return @readonly;
+        }
 
-		public virtual void SetReadonly(bool @readonly)
-		{
-			this.@readonly = @readonly;
-		}
-	}
+        public virtual void SetReadonly(bool @readonly)
+        {
+            this.@readonly = @readonly;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/MultiMap`2.cs b/Antlr4.Runtime/Misc/MultiMap`2.cs
index fc0c9fae5..1c71b20f9 100644
--- a/Antlr4.Runtime/Misc/MultiMap`2.cs
+++ b/Antlr4.Runtime/Misc/MultiMap`2.cs
@@ -34,33 +34,33 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	[System.Serializable]
-	public class MultiMap<K, V> : LinkedHashMap<K, IList<V>>
-	{
-		private const long serialVersionUID = -4956746660057462312L;
+    [System.Serializable]
+    public class MultiMap<K, V> : LinkedHashMap<K, IList<V>>
+    {
+        private const long serialVersionUID = -4956746660057462312L;
 
-		public virtual void Map(K key, V value)
-		{
-			IList<V> elementsForKey = Get(key);
-			if (elementsForKey == null)
-			{
-				elementsForKey = new List<V>();
-				base.Put(key, elementsForKey);
-			}
-			elementsForKey.AddItem(value);
-		}
+        public virtual void Map(K key, V value)
+        {
+            IList<V> elementsForKey = Get(key);
+            if (elementsForKey == null)
+            {
+                elementsForKey = new List<V>();
+                base.Put(key, elementsForKey);
+            }
+            elementsForKey.AddItem(value);
+        }
 
-		public virtual IList<Tuple<K, V>> GetPairs()
-		{
-			IList<Tuple<K, V>> pairs = new List<Tuple<K, V>>();
-			foreach (K key in Keys)
-			{
-				foreach (V value in Get(key))
-				{
-					pairs.AddItem(Tuple.Create(key, value));
-				}
-			}
-			return pairs;
-		}
-	}
+        public virtual IList<Tuple<K, V>> GetPairs()
+        {
+            IList<Tuple<K, V>> pairs = new List<Tuple<K, V>>();
+            foreach (K key in Keys)
+            {
+                foreach (V value in Get(key))
+                {
+                    pairs.AddItem(Tuple.Create(key, value));
+                }
+            }
+            return pairs;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/OrderedHashSet`1.cs b/Antlr4.Runtime/Misc/OrderedHashSet`1.cs
index 875941603..47efc5d58 100644
--- a/Antlr4.Runtime/Misc/OrderedHashSet`1.cs
+++ b/Antlr4.Runtime/Misc/OrderedHashSet`1.cs
@@ -34,131 +34,131 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>A HashMap that remembers the order that the elements were added.</summary>
-	/// <remarks>
-	/// A HashMap that remembers the order that the elements were added.
-	/// You can alter the ith element with set(i,value) too :)  Unique list.
-	/// I need the replace/set-element-i functionality so I'm subclassing
-	/// LinkedHashSet.
-	/// </remarks>
-	[System.Serializable]
-	public class OrderedHashSet<T> : LinkedHashSet<T>
-	{
-		private const long serialVersionUID = 5281944403755906761L;
+    /// <summary>A HashMap that remembers the order that the elements were added.</summary>
+    /// <remarks>
+    /// A HashMap that remembers the order that the elements were added.
+    /// You can alter the ith element with set(i,value) too :)  Unique list.
+    /// I need the replace/set-element-i functionality so I'm subclassing
+    /// LinkedHashSet.
+    /// </remarks>
+    [System.Serializable]
+    public class OrderedHashSet<T> : LinkedHashSet<T>
+    {
+        private const long serialVersionUID = 5281944403755906761L;
 
-		/// <summary>Track the elements as they are added to the set</summary>
-		protected internal List<T> elements = new List<T>();
+        /// <summary>Track the elements as they are added to the set</summary>
+        protected internal List<T> elements = new List<T>();
 
-		public virtual T Get(int i)
-		{
-			return elements[i];
-		}
+        public virtual T Get(int i)
+        {
+            return elements[i];
+        }
 
-		/// <summary>
-		/// Replace an existing value with a new value; updates the element
-		/// list and the hash table, but not the key as that has not changed.
-		/// </summary>
-		/// <remarks>
-		/// Replace an existing value with a new value; updates the element
-		/// list and the hash table, but not the key as that has not changed.
-		/// </remarks>
-		public virtual T Set(int i, T value)
-		{
-			T oldElement = elements[i];
-			elements.Set(i, value);
-			// update list
-			base.Remove(oldElement);
-			// now update the set: remove/add
-			base.AddItem(value);
-			return oldElement;
-		}
+        /// <summary>
+        /// Replace an existing value with a new value; updates the element
+        /// list and the hash table, but not the key as that has not changed.
+        /// </summary>
+        /// <remarks>
+        /// Replace an existing value with a new value; updates the element
+        /// list and the hash table, but not the key as that has not changed.
+        /// </remarks>
+        public virtual T Set(int i, T value)
+        {
+            T oldElement = elements[i];
+            elements.Set(i, value);
+            // update list
+            base.Remove(oldElement);
+            // now update the set: remove/add
+            base.AddItem(value);
+            return oldElement;
+        }
 
-		public virtual bool Remove(int i)
-		{
-			T o = elements.Remove(i);
-			return base.Remove(o);
-		}
+        public virtual bool Remove(int i)
+        {
+            T o = elements.Remove(i);
+            return base.Remove(o);
+        }
 
-		/// <summary>
-		/// Add a value to list; keep in hashtable for consistency also;
-		/// Key is object itself.
-		/// </summary>
-		/// <remarks>
-		/// Add a value to list; keep in hashtable for consistency also;
-		/// Key is object itself.  Good for say asking if a certain string is in
-		/// a list of strings.
-		/// </remarks>
-		public override bool AddItem(T value)
-		{
-			bool result = base.AddItem(value);
-			if (result)
-			{
-				// only track if new element not in set
-				elements.AddItem(value);
-			}
-			return result;
-		}
+        /// <summary>
+        /// Add a value to list; keep in hashtable for consistency also;
+        /// Key is object itself.
+        /// </summary>
+        /// <remarks>
+        /// Add a value to list; keep in hashtable for consistency also;
+        /// Key is object itself.  Good for say asking if a certain string is in
+        /// a list of strings.
+        /// </remarks>
+        public override bool AddItem(T value)
+        {
+            bool result = base.AddItem(value);
+            if (result)
+            {
+                // only track if new element not in set
+                elements.AddItem(value);
+            }
+            return result;
+        }
 
-		public override bool Remove(object o)
-		{
-			throw new NotSupportedException();
-		}
+        public override bool Remove(object o)
+        {
+            throw new NotSupportedException();
+        }
 
-		public override void Clear()
-		{
-			elements.Clear();
-			base.Clear();
-		}
+        public override void Clear()
+        {
+            elements.Clear();
+            base.Clear();
+        }
 
-		public override int GetHashCode()
-		{
-			return elements.GetHashCode();
-		}
+        public override int GetHashCode()
+        {
+            return elements.GetHashCode();
+        }
 
-		public override bool Equals(object o)
-		{
-			if (!(o is OrderedHashSet<object>))
-			{
-				return false;
-			}
-			//		System.out.print("equals " + this + ", " + o+" = ");
-			bool same = elements != null && elements.Equals(((OrderedHashSet<object>)o).elements
-				);
-			//		System.out.println(same);
-			return same;
-		}
+        public override bool Equals(object o)
+        {
+            if (!(o is OrderedHashSet<object>))
+            {
+                return false;
+            }
+            //		System.out.print("equals " + this + ", " + o+" = ");
+            bool same = elements != null && elements.Equals(((OrderedHashSet<object>)o).elements
+                );
+            //		System.out.println(same);
+            return same;
+        }
 
-		public override IEnumerator<T> GetEnumerator()
-		{
-			return elements.GetEnumerator();
-		}
+        public override IEnumerator<T> GetEnumerator()
+        {
+            return elements.GetEnumerator();
+        }
 
-		/// <summary>Return the List holding list of table elements.</summary>
-		/// <remarks>
-		/// Return the List holding list of table elements.  Note that you are
-		/// NOT getting a copy so don't write to the list.
-		/// </remarks>
-		public virtual IList<T> Elements()
-		{
-			return elements;
-		}
+        /// <summary>Return the List holding list of table elements.</summary>
+        /// <remarks>
+        /// Return the List holding list of table elements.  Note that you are
+        /// NOT getting a copy so don't write to the list.
+        /// </remarks>
+        public virtual IList<T> Elements()
+        {
+            return elements;
+        }
 
-		public override object Clone()
-		{
-			OrderedHashSet<T> dup = (OrderedHashSet<T>)base.Clone();
-			// safe (result of clone)
-			dup.elements = new List<T>(this.elements);
-			return dup;
-		}
+        public override object Clone()
+        {
+            OrderedHashSet<T> dup = (OrderedHashSet<T>)base.Clone();
+            // safe (result of clone)
+            dup.elements = new List<T>(this.elements);
+            return dup;
+        }
 
-		public override object[] ToArray()
-		{
-			return Sharpen.Collections.ToArray(elements);
-		}
+        public override object[] ToArray()
+        {
+            return Sharpen.Collections.ToArray(elements);
+        }
 
-		public override string ToString()
-		{
-			return elements.ToString();
-		}
-	}
+        public override string ToString()
+        {
+            return elements.ToString();
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/ParseCanceledException.cs b/Antlr4.Runtime/Misc/ParseCanceledException.cs
index 60a16df84..a92a91cb2 100644
--- a/Antlr4.Runtime/Misc/ParseCanceledException.cs
+++ b/Antlr4.Runtime/Misc/ParseCanceledException.cs
@@ -32,40 +32,40 @@ using Sharpen;
 
 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">Antlr4.Runtime.RecognitionException
-	/// 	</see>
-	/// , allowing it to bypass the standard
-	/// error recovery mechanisms.
-	/// <see cref="Antlr4.Runtime.BailErrorStrategy">Antlr4.Runtime.BailErrorStrategy</see>
-	/// throws this exception in
-	/// response to a parse error.
-	/// </remarks>
-	/// <author>Sam Harwell</author>
-	[System.Serializable]
-	public class ParseCanceledException : OperationCanceledException
-	{
-		private const long serialVersionUID = -3529552099366979683L;
+    /// <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">Antlr4.Runtime.RecognitionException
+    ///     </see>
+    /// , allowing it to bypass the standard
+    /// error recovery mechanisms.
+    /// <see cref="Antlr4.Runtime.BailErrorStrategy">Antlr4.Runtime.BailErrorStrategy</see>
+    /// throws this exception in
+    /// response to a parse error.
+    /// </remarks>
+    /// <author>Sam Harwell</author>
+    [System.Serializable]
+    public class ParseCanceledException : OperationCanceledException
+    {
+        private const long serialVersionUID = -3529552099366979683L;
 
-		public ParseCanceledException()
-		{
-		}
+        public ParseCanceledException()
+        {
+        }
 
-		public ParseCanceledException(string message) : base(message)
-		{
-		}
+        public ParseCanceledException(string message) : base(message)
+        {
+        }
 
-		public ParseCanceledException(Exception cause)
-		{
-			Sharpen.Extensions.InitCause(this, cause);
-		}
+        public ParseCanceledException(Exception cause)
+        {
+            Sharpen.Extensions.InitCause(this, cause);
+        }
 
-		public ParseCanceledException(string message, Exception cause) : base(message)
-		{
-			Sharpen.Extensions.InitCause(this, cause);
-		}
-	}
+        public ParseCanceledException(string message, Exception cause) : base(message)
+        {
+            Sharpen.Extensions.InitCause(this, cause);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/RuleDependencyChecker.cs b/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
index 87299fc9e..edca97dc8 100644
--- a/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
+++ b/Antlr4.Runtime/Misc/RuleDependencyChecker.cs
@@ -40,288 +40,289 @@ using Sharpen.Reflect;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <author>Sam Harwell</author>
-	public class RuleDependencyChecker
-	{
-		private static readonly Logger Logger = Logger.GetLogger(typeof(Antlr4.Runtime.Misc.RuleDependencyChecker
-			).FullName);
+    /// <author>Sam Harwell</author>
+    public class RuleDependencyChecker
+    {
+        private static readonly Logger Logger = Logger.GetLogger(typeof(Antlr4.Runtime.Misc.RuleDependencyChecker
+            ).FullName);
 
-		private static readonly ICollection<Type> checkedTypes = new HashSet<Type>();
+        private static readonly ICollection<Type> checkedTypes = new HashSet<Type>();
 
-		public static void CheckDependencies<_T0>(Type<_T0> dependentClass)
-		{
-			if (IsChecked(dependentClass))
-			{
-				return;
-			}
-			IList<Type> typesToCheck = new List<Type>();
-			typesToCheck.AddItem(dependentClass);
-			Sharpen.Collections.AddAll(typesToCheck, dependentClass.GetDeclaredClasses());
-			foreach (Type clazz in typesToCheck)
-			{
-				if (IsChecked(clazz))
-				{
-					continue;
-				}
-				IList<Tuple<RuleDependency, IAnnotatedElement>> dependencies = GetDependencies(clazz
-					);
-				if (dependencies.IsEmpty())
-				{
-					continue;
-				}
-				CheckDependencies(dependencies, dependencies[0].GetItem1().Recognizer());
-			}
-		}
+        public static void CheckDependencies<_T0>(Type<_T0> dependentClass)
+        {
+            if (IsChecked(dependentClass))
+            {
+                return;
+            }
+            IList<Type> typesToCheck = new List<Type>();
+            typesToCheck.AddItem(dependentClass);
+            Sharpen.Collections.AddAll(typesToCheck, dependentClass.GetDeclaredClasses());
+            foreach (Type clazz in typesToCheck)
+            {
+                if (IsChecked(clazz))
+                {
+                    continue;
+                }
+                IList<Tuple<RuleDependency, IAnnotatedElement>> dependencies = GetDependencies(clazz
+                    );
+                if (dependencies.IsEmpty())
+                {
+                    continue;
+                }
+                CheckDependencies(dependencies, dependencies[0].GetItem1().Recognizer());
+            }
+        }
 
-		private static bool IsChecked<_T0>(Type<_T0> clazz)
-		{
-			lock (checkedTypes)
-			{
-				return checkedTypes.Contains(clazz);
-			}
-		}
+        private static bool IsChecked<_T0>(Type<_T0> clazz)
+        {
+            lock (checkedTypes)
+            {
+                return checkedTypes.Contains(clazz);
+            }
+        }
 
-		private static void MarkChecked<_T0>(Type<_T0> clazz)
-		{
-			lock (checkedTypes)
-			{
-				checkedTypes.AddItem(clazz);
-			}
-		}
+        private static void MarkChecked<_T0>(Type<_T0> clazz)
+        {
+            lock (checkedTypes)
+            {
+                checkedTypes.AddItem(clazz);
+            }
+        }
 
-		private static void CheckDependencies<_T0>(IList<Tuple<RuleDependency, IAnnotatedElement
-			>> dependencies, Type<_T0> recognizerClass) where _T0:Recognizer<object, object>
-		{
-			string[] ruleNames = GetRuleNames(recognizerClass);
-			int[] ruleVersions = GetRuleVersions(recognizerClass, ruleNames);
-			StringBuilder incompatible = new StringBuilder();
-			foreach (Tuple<RuleDependency, IAnnotatedElement> dependency in dependencies)
-			{
-				if (!recognizerClass.IsAssignableFrom(dependency.GetItem1().Recognizer()))
-				{
-					continue;
-				}
-				if (dependency.GetItem1().Rule() < 0 || dependency.GetItem1().Rule() >= ruleVersions
-					.Length)
-				{
-					incompatible.Append(string.Format("Element %s dependent on unknown rule %d@%d in %s\n"
-						, dependency.GetItem2().ToString(), dependency.GetItem1().Rule(), dependency.GetItem1
-						().Version(), dependency.GetItem1().Recognizer().Name));
-				}
-				else
-				{
-					if (ruleVersions[dependency.GetItem1().Rule()] != dependency.GetItem1().Version())
-					{
-						incompatible.Append(string.Format("Element %s dependent on rule %s@%d (found @%d) in %s\n"
-							, dependency.GetItem2().ToString(), ruleNames[dependency.GetItem1().Rule()], dependency
-							.GetItem1().Version(), ruleVersions[dependency.GetItem1().Rule()], dependency.GetItem1
-							().Recognizer().Name));
-					}
-				}
-			}
-			if (incompatible.Length != 0)
-			{
-				throw new InvalidOperationException(incompatible.ToString());
-			}
-			MarkChecked(recognizerClass);
-		}
+        private static void CheckDependencies<_T0>(IList<Tuple<RuleDependency, IAnnotatedElement
+            >> dependencies, Type<_T0> recognizerClass) where _T0:Recognizer<object, object
+            >
+        {
+            string[] ruleNames = GetRuleNames(recognizerClass);
+            int[] ruleVersions = GetRuleVersions(recognizerClass, ruleNames);
+            StringBuilder incompatible = new StringBuilder();
+            foreach (Tuple<RuleDependency, IAnnotatedElement> dependency in dependencies)
+            {
+                if (!recognizerClass.IsAssignableFrom(dependency.GetItem1().Recognizer()))
+                {
+                    continue;
+                }
+                if (dependency.GetItem1().Rule() < 0 || dependency.GetItem1().Rule() >= ruleVersions
+                    .Length)
+                {
+                    incompatible.Append(string.Format("Element %s dependent on unknown rule %d@%d in %s\n"
+                        , dependency.GetItem2().ToString(), dependency.GetItem1().Rule(), dependency.
+                        GetItem1().Version(), dependency.GetItem1().Recognizer().Name));
+                }
+                else
+                {
+                    if (ruleVersions[dependency.GetItem1().Rule()] != dependency.GetItem1().Version())
+                    {
+                        incompatible.Append(string.Format("Element %s dependent on rule %s@%d (found @%d) in %s\n"
+                            , dependency.GetItem2().ToString(), ruleNames[dependency.GetItem1().Rule()], 
+                            dependency.GetItem1().Version(), ruleVersions[dependency.GetItem1().Rule()], 
+                            dependency.GetItem1().Recognizer().Name));
+                    }
+                }
+            }
+            if (incompatible.Length != 0)
+            {
+                throw new InvalidOperationException(incompatible.ToString());
+            }
+            MarkChecked(recognizerClass);
+        }
 
-		private static int[] GetRuleVersions<_T0>(Type<_T0> recognizerClass, string[] ruleNames
-			) where _T0:Recognizer<object, object>
-		{
-			int[] versions = new int[ruleNames.Length];
-			FieldInfo[] fields = recognizerClass.GetFields();
-			foreach (FieldInfo field in fields)
-			{
-				bool isStatic = (field.GetModifiers() & Modifier.Static) != 0;
-				bool isInteger = field.FieldType == typeof(int);
-				if (isStatic && isInteger && field.Name.StartsWith("RULE_"))
-				{
-					try
-					{
-						string name = Sharpen.Runtime.Substring(field.Name, "RULE_".Length);
-						if (name.IsEmpty() || !System.Char.IsLower(name[0]))
-						{
-							continue;
-						}
-						int index = field.GetInt(null);
-						if (index < 0 || index >= versions.Length)
-						{
-							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);
-							continue;
-						}
-						MethodInfo ruleMethod = GetRuleMethod(recognizerClass, name);
-						if (ruleMethod == null)
-						{
-							object[] @params = new object[] { name, recognizerClass.Name };
-							Logger.Log(Level.Warning, "Could not find rule method for rule ''{0}'' in recognizer {1}."
-								, @params);
-							continue;
-						}
-						RuleVersion ruleVersion = ruleMethod.GetAnnotation<RuleVersion>();
-						int version = ruleVersion != null ? ruleVersion.Value() : 0;
-						versions[index] = version;
-					}
-					catch (ArgumentException ex)
-					{
-						Logger.Log(Level.Warning, null, ex);
-					}
-					catch (MemberAccessException ex)
-					{
-						Logger.Log(Level.Warning, null, ex);
-					}
-				}
-			}
-			return versions;
-		}
+        private static int[] GetRuleVersions<_T0>(Type<_T0> recognizerClass, string[] ruleNames
+            ) where _T0:Recognizer<object, object>
+        {
+            int[] versions = new int[ruleNames.Length];
+            FieldInfo[] fields = recognizerClass.GetFields();
+            foreach (FieldInfo field in fields)
+            {
+                bool isStatic = (field.GetModifiers() & Modifier.Static) != 0;
+                bool isInteger = field.FieldType == typeof(int);
+                if (isStatic && isInteger && field.Name.StartsWith("RULE_"))
+                {
+                    try
+                    {
+                        string name = Sharpen.Runtime.Substring(field.Name, "RULE_".Length);
+                        if (name.IsEmpty() || !System.Char.IsLower(name[0]))
+                        {
+                            continue;
+                        }
+                        int index = field.GetInt(null);
+                        if (index < 0 || index >= versions.Length)
+                        {
+                            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);
+                            continue;
+                        }
+                        MethodInfo ruleMethod = GetRuleMethod(recognizerClass, name);
+                        if (ruleMethod == null)
+                        {
+                            object[] @params = new object[] { name, recognizerClass.Name };
+                            Logger.Log(Level.Warning, "Could not find rule method for rule ''{0}'' in recognizer {1}."
+                                , @params);
+                            continue;
+                        }
+                        RuleVersion ruleVersion = ruleMethod.GetAnnotation<RuleVersion>();
+                        int version = ruleVersion != null ? ruleVersion.Value() : 0;
+                        versions[index] = version;
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        Logger.Log(Level.Warning, null, ex);
+                    }
+                    catch (MemberAccessException ex)
+                    {
+                        Logger.Log(Level.Warning, null, ex);
+                    }
+                }
+            }
+            return versions;
+        }
 
-		private static MethodInfo GetRuleMethod<_T0>(Type<_T0> recognizerClass, string name
-			) where _T0:Recognizer<object, object>
-		{
-			MethodInfo[] declaredMethods = recognizerClass.GetMethods();
-			foreach (MethodInfo method in declaredMethods)
-			{
-				if (method.Name.Equals(name) && method.IsAnnotationPresent(typeof(RuleVersion)))
-				{
-					return method;
-				}
-			}
-			return null;
-		}
+        private static MethodInfo GetRuleMethod<_T0>(Type<_T0> recognizerClass, string name
+            ) where _T0:Recognizer<object, object>
+        {
+            MethodInfo[] declaredMethods = recognizerClass.GetMethods();
+            foreach (MethodInfo method in declaredMethods)
+            {
+                if (method.Name.Equals(name) && method.IsAnnotationPresent(typeof(RuleVersion)))
+                {
+                    return method;
+                }
+            }
+            return null;
+        }
 
-		private static string[] GetRuleNames<_T0>(Type<_T0> recognizerClass) where _T0:Recognizer
-			<object, object>
-		{
-			try
-			{
-				FieldInfo ruleNames = recognizerClass.GetField("ruleNames");
-				return (string[])ruleNames.GetValue(null);
-			}
-			catch (NoSuchFieldException ex)
-			{
-				Logger.Log(Level.Warning, null, ex);
-			}
-			catch (SecurityException ex)
-			{
-				Logger.Log(Level.Warning, null, ex);
-			}
-			catch (ArgumentException ex)
-			{
-				Logger.Log(Level.Warning, null, ex);
-			}
-			catch (MemberAccessException ex)
-			{
-				Logger.Log(Level.Warning, null, ex);
-			}
-			return new string[0];
-		}
+        private static string[] GetRuleNames<_T0>(Type<_T0> recognizerClass) where _T0:Recognizer
+            <object, object>
+        {
+            try
+            {
+                FieldInfo ruleNames = recognizerClass.GetField("ruleNames");
+                return (string[])ruleNames.GetValue(null);
+            }
+            catch (NoSuchFieldException ex)
+            {
+                Logger.Log(Level.Warning, null, ex);
+            }
+            catch (SecurityException ex)
+            {
+                Logger.Log(Level.Warning, null, ex);
+            }
+            catch (ArgumentException ex)
+            {
+                Logger.Log(Level.Warning, null, ex);
+            }
+            catch (MemberAccessException ex)
+            {
+                Logger.Log(Level.Warning, null, ex);
+            }
+            return new string[0];
+        }
 
-		public static IList<Tuple<RuleDependency, IAnnotatedElement>> GetDependencies<_T0
-			>(Type<_T0> clazz)
-		{
-			IList<Tuple<RuleDependency, IAnnotatedElement>> result = new List<Tuple<RuleDependency
-				, IAnnotatedElement>>();
-			IList<ElementType> supportedTarget = Arrays.AsList(typeof(RuleDependency).GetAnnotation
-				<Target>().Value());
-			foreach (ElementType target in supportedTarget)
-			{
-				switch (target)
-				{
-					case ElementType.Type:
-					{
-						if (!clazz.IsAnnotation())
-						{
-							GetElementDependencies(clazz, result);
-						}
-						break;
-					}
+        public static IList<Tuple<RuleDependency, IAnnotatedElement>> GetDependencies<_T0
+            >(Type<_T0> clazz)
+        {
+            IList<Tuple<RuleDependency, IAnnotatedElement>> result = new List<Tuple<RuleDependency
+                , IAnnotatedElement>>();
+            IList<ElementType> supportedTarget = Arrays.AsList(typeof(RuleDependency).GetAnnotation
+                <Target>().Value());
+            foreach (ElementType target in supportedTarget)
+            {
+                switch (target)
+                {
+                    case ElementType.Type:
+                    {
+                        if (!clazz.IsAnnotation())
+                        {
+                            GetElementDependencies(clazz, result);
+                        }
+                        break;
+                    }
 
-					case ElementType.AnnotationType:
-					{
-						if (!clazz.IsAnnotation())
-						{
-							GetElementDependencies(clazz, result);
-						}
-						break;
-					}
+                    case ElementType.AnnotationType:
+                    {
+                        if (!clazz.IsAnnotation())
+                        {
+                            GetElementDependencies(clazz, result);
+                        }
+                        break;
+                    }
 
-					case ElementType.Constructor:
-					{
-						foreach (Constructor<object> ctor in clazz.GetDeclaredConstructors())
-						{
-							GetElementDependencies(ctor, result);
-						}
-						break;
-					}
+                    case ElementType.Constructor:
+                    {
+                        foreach (Constructor<object> ctor in clazz.GetDeclaredConstructors())
+                        {
+                            GetElementDependencies(ctor, result);
+                        }
+                        break;
+                    }
 
-					case ElementType.Field:
-					{
-						foreach (FieldInfo field in Sharpen.Runtime.GetDeclaredFields(clazz))
-						{
-							GetElementDependencies(field, result);
-						}
-						break;
-					}
+                    case ElementType.Field:
+                    {
+                        foreach (FieldInfo field in Sharpen.Runtime.GetDeclaredFields(clazz))
+                        {
+                            GetElementDependencies(field, result);
+                        }
+                        break;
+                    }
 
-					case ElementType.LocalVariable:
-					{
-						System.Console.Error.WriteLine("Runtime rule dependency checking is not supported for local variables."
-							);
-						break;
-					}
+                    case ElementType.LocalVariable:
+                    {
+                        System.Console.Error.WriteLine("Runtime rule dependency checking is not supported for local variables."
+                            );
+                        break;
+                    }
 
-					case ElementType.Method:
-					{
-						foreach (MethodInfo method in Sharpen.Runtime.GetDeclaredMethods(clazz))
-						{
-							GetElementDependencies(method, result);
-						}
-						break;
-					}
+                    case ElementType.Method:
+                    {
+                        foreach (MethodInfo method in Sharpen.Runtime.GetDeclaredMethods(clazz))
+                        {
+                            GetElementDependencies(method, result);
+                        }
+                        break;
+                    }
 
-					case ElementType.Package:
-					{
-						// package is not a subset of class, so nothing to do here
-						break;
-					}
+                    case ElementType.Package:
+                    {
+                        // package is not a subset of class, so nothing to do here
+                        break;
+                    }
 
-					case ElementType.Parameter:
-					{
-						System.Console.Error.WriteLine("Runtime rule dependency checking is not supported for parameters."
-							);
-						break;
-					}
-				}
-			}
-			return result;
-		}
+                    case ElementType.Parameter:
+                    {
+                        System.Console.Error.WriteLine("Runtime rule dependency checking is not supported for parameters."
+                            );
+                        break;
+                    }
+                }
+            }
+            return result;
+        }
 
-		private static void GetElementDependencies(IAnnotatedElement annotatedElement, IList
-			<Tuple<RuleDependency, IAnnotatedElement>> result)
-		{
-			RuleDependency dependency = annotatedElement.GetAnnotation<RuleDependency>();
-			if (dependency != null)
-			{
-				result.AddItem(Tuple.Create(dependency, annotatedElement));
-			}
-			RuleDependencies dependencies = annotatedElement.GetAnnotation<RuleDependencies>(
-				);
-			if (dependencies != null)
-			{
-				foreach (RuleDependency d in dependencies.Value())
-				{
-					if (d != null)
-					{
-						result.AddItem(Tuple.Create(d, annotatedElement));
-					}
-				}
-			}
-		}
+        private static void GetElementDependencies(IAnnotatedElement annotatedElement, IList
+            <Tuple<RuleDependency, IAnnotatedElement>> result)
+        {
+            RuleDependency dependency = annotatedElement.GetAnnotation<RuleDependency>();
+            if (dependency != null)
+            {
+                result.AddItem(Tuple.Create(dependency, annotatedElement));
+            }
+            RuleDependencies dependencies = annotatedElement.GetAnnotation<RuleDependencies>(
+                );
+            if (dependencies != null)
+            {
+                foreach (RuleDependency d in dependencies.Value())
+                {
+                    if (d != null)
+                    {
+                        result.AddItem(Tuple.Create(d, annotatedElement));
+                    }
+                }
+            }
+        }
 
-		public RuleDependencyChecker()
-		{
-		}
-	}
+        public RuleDependencyChecker()
+        {
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
index 1d2c4f61b..01cd55879 100644
--- a/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
+++ b/Antlr4.Runtime/Misc/RuleDependencyProcessor.cs
@@ -42,818 +42,820 @@ using Sharpen.Annotation;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>A compile-time validator for rule dependencies.</summary>
-	/// <remarks>A compile-time validator for rule dependencies.</remarks>
-	/// <seealso cref="Antlr4.Runtime.RuleDependency">Antlr4.Runtime.RuleDependency</seealso>
-	/// <seealso cref="Antlr4.Runtime.RuleDependencies">Antlr4.Runtime.RuleDependencies</seealso>
-	/// <author>Sam Harwell</author>
-	public class RuleDependencyProcessor : AbstractProcessor
-	{
-		public static readonly string RuleDependencyClassName = "org.antlr.v4.runtime.RuleDependency";
+    /// <summary>A compile-time validator for rule dependencies.</summary>
+    /// <remarks>A compile-time validator for rule dependencies.</remarks>
+    /// <seealso cref="Antlr4.Runtime.RuleDependency">Antlr4.Runtime.RuleDependency</seealso>
+    /// <seealso cref="Antlr4.Runtime.RuleDependencies">Antlr4.Runtime.RuleDependencies</seealso>
+    /// <author>Sam Harwell</author>
+    public class RuleDependencyProcessor : AbstractProcessor
+    {
+        public static readonly string RuleDependencyClassName = "org.antlr.v4.runtime.RuleDependency";
 
-		public static readonly string RuleDependenciesClassName = "org.antlr.v4.runtime.RuleDependencies";
+        public static readonly string RuleDependenciesClassName = "org.antlr.v4.runtime.RuleDependencies";
 
-		public static readonly string RuleVersionClassName = "org.antlr.v4.runtime.RuleVersion";
+        public static readonly string RuleVersionClassName = "org.antlr.v4.runtime.RuleVersion";
 
-		public RuleDependencyProcessor()
-		{
-		}
+        public RuleDependencyProcessor()
+        {
+        }
 
-		public override bool Process<_T0>(ICollection<_T0> annotations, IRoundEnvironment
-			 roundEnv)
-		{
-			if (!CheckClassNameConstants())
-			{
-				return true;
-			}
-			IList<Tuple<RuleDependency, IElement>> dependencies = GetDependencies(roundEnv);
-			IDictionary<ITypeMirror, IList<Tuple<RuleDependency, IElement>>> recognizerDependencies
-				 = new Dictionary<ITypeMirror, IList<Tuple<RuleDependency, IElement>>>();
-			foreach (Tuple<RuleDependency, IElement> dependency in dependencies)
-			{
-				ITypeMirror recognizerType = GetRecognizerType(dependency.GetItem1());
-				IList<Tuple<RuleDependency, IElement>> list = recognizerDependencies.Get(recognizerType
-					);
-				if (list == null)
-				{
-					list = new List<Tuple<RuleDependency, IElement>>();
-					recognizerDependencies.Put(recognizerType, list);
-				}
-				list.AddItem(dependency);
-			}
-			foreach (KeyValuePair<ITypeMirror, IList<Tuple<RuleDependency, IElement>>> entry in 
-				recognizerDependencies.EntrySet())
-			{
-				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Note, string.Format("ANTLR 4: Validating %d dependencies on rules in %s."
-					, entry.Value.Count, entry.Key.ToString()));
-				CheckDependencies(entry.Value, entry.Key);
-			}
-			return true;
-		}
+        public override bool Process<_T0>(ICollection<_T0> annotations, IRoundEnvironment
+             roundEnv)
+        {
+            if (!CheckClassNameConstants())
+            {
+                return true;
+            }
+            IList<Tuple<RuleDependency, IElement>> dependencies = GetDependencies(roundEnv);
+            IDictionary<ITypeMirror, IList<Tuple<RuleDependency, IElement>>> recognizerDependencies
+                 = new Dictionary<ITypeMirror, IList<Tuple<RuleDependency, IElement>>>();
+            foreach (Tuple<RuleDependency, IElement> dependency in dependencies)
+            {
+                ITypeMirror recognizerType = GetRecognizerType(dependency.GetItem1());
+                IList<Tuple<RuleDependency, IElement>> list = recognizerDependencies.Get(recognizerType
+                    );
+                if (list == null)
+                {
+                    list = new List<Tuple<RuleDependency, IElement>>();
+                    recognizerDependencies.Put(recognizerType, list);
+                }
+                list.AddItem(dependency);
+            }
+            foreach (KeyValuePair<ITypeMirror, IList<Tuple<RuleDependency, IElement>>> entry in 
+                recognizerDependencies.EntrySet())
+            {
+                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Note, string.Format("ANTLR 4: Validating %d dependencies on rules in %s."
+                    , entry.Value.Count, entry.Key.ToString()));
+                CheckDependencies(entry.Value, entry.Key);
+            }
+            return true;
+        }
 
-		private bool CheckClassNameConstants()
-		{
-			bool success = CheckClassNameConstant(RuleDependencyClassName, typeof(RuleDependency
-				));
-			success &= CheckClassNameConstant(RuleDependenciesClassName, typeof(RuleDependencies
-				));
-			success &= CheckClassNameConstant(RuleVersionClassName, typeof(RuleVersion));
-			return success;
-		}
+        private bool CheckClassNameConstants()
+        {
+            bool success = CheckClassNameConstant(RuleDependencyClassName, typeof(RuleDependency
+                ));
+            success &= CheckClassNameConstant(RuleDependenciesClassName, typeof(RuleDependencies
+                ));
+            success &= CheckClassNameConstant(RuleVersionClassName, typeof(RuleVersion));
+            return success;
+        }
 
-		private bool CheckClassNameConstant<_T0>(string className, System.Type<_T0> clazz
-			)
-		{
-			Args.NotNull("className", className);
-			Args.NotNull("clazz", clazz);
-			if (!className.Equals(clazz.GetCanonicalName()))
-			{
-				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, string.Format("Unable to process rule dependencies due to class name mismatch: %s != %s"
-					, className, clazz.GetCanonicalName()));
-				return false;
-			}
-			return true;
-		}
+        private bool CheckClassNameConstant<_T0>(string className, System.Type<_T0> clazz
+            )
+        {
+            Args.NotNull("className", className);
+            Args.NotNull("clazz", clazz);
+            if (!className.Equals(clazz.GetCanonicalName()))
+            {
+                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, string.Format("Unable to process rule dependencies due to class name mismatch: %s != %s"
+                    , className, clazz.GetCanonicalName()));
+                return false;
+            }
+            return true;
+        }
 
-		private static ITypeMirror GetRecognizerType(RuleDependency dependency)
-		{
-			try
-			{
-				dependency.Recognizer();
-				string message = string.Format("Expected %s to get the %s.", typeof(MirroredTypeException
-					).Name, typeof(ITypeMirror).Name);
-				throw new NotSupportedException(message);
-			}
-			catch (MirroredTypeException ex)
-			{
-				return ex.GetTypeMirror();
-			}
-		}
+        private static ITypeMirror GetRecognizerType(RuleDependency dependency)
+        {
+            try
+            {
+                dependency.Recognizer();
+                string message = string.Format("Expected %s to get the %s.", typeof(MirroredTypeException
+                    ).Name, typeof(ITypeMirror).Name);
+                throw new NotSupportedException(message);
+            }
+            catch (MirroredTypeException ex)
+            {
+                return ex.GetTypeMirror();
+            }
+        }
 
-		private void CheckDependencies(IList<Tuple<RuleDependency, IElement>> dependencies
-			, ITypeMirror recognizerType)
-		{
-			string[] ruleNames = GetRuleNames(recognizerType);
-			int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
-			RuleDependencyProcessor.RuleRelations relations = ExtractRuleRelations(recognizerType
-				);
-			foreach (Tuple<RuleDependency, IElement> dependency in dependencies)
-			{
-				try
-				{
-					if (!processingEnv.GetTypeUtils().IsAssignable(GetRecognizerType(dependency.GetItem1
-						()), recognizerType))
-					{
-						continue;
-					}
-					// this is the rule in the dependency set with the highest version number
-					int effectiveRule = dependency.GetItem1().Rule();
-					if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
-					{
-						Tuple<IAnnotationMirror, IAnnotationValue> ruleReferenceElement = FindRuleDependencyProperty
-							(dependency, RuleDependencyProcessor.RuleDependencyProperty.Rule);
-						string message = string.Format("Rule dependency on unknown rule %d@%d in %s", dependency
-							.GetItem1().Rule(), dependency.GetItem1().Version(), GetRecognizerType(dependency
-							.GetItem1()).ToString());
-						if (ruleReferenceElement != null)
-						{
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
-								.GetItem2(), ruleReferenceElement.GetItem1(), ruleReferenceElement.GetItem2());
-						}
-						else
-						{
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
-								.GetItem2());
-						}
-						continue;
-					}
-					EnumSet<Dependents> dependents = EnumSet.Of(Dependents.Self, dependency.GetItem1(
-						).Dependents());
-					ReportUnimplementedDependents(dependency, dependents);
-					BitSet checked = new BitSet();
-					int highestRequiredDependency = CheckDependencyVersion(dependency, ruleNames, ruleVersions
-						, effectiveRule, null);
-					if (dependents.Contains(Dependents.Parents))
-					{
-						BitSet parents = relations.parents[dependency.GetItem1().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(dependency, ruleNames, ruleVersions, parent
-								, "parent");
-							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
-						}
-					}
-					if (dependents.Contains(Dependents.Children))
-					{
-						BitSet children = relations.children[dependency.GetItem1().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(dependency, ruleNames, ruleVersions, child, 
-								"child");
-							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
-						}
-					}
-					if (dependents.Contains(Dependents.Ancestors))
-					{
-						BitSet ancestors = relations.GetAncestors(dependency.GetItem1().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(dependency, ruleNames, ruleVersions, ancestor
-								, "ancestor");
-							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
-						}
-					}
-					if (dependents.Contains(Dependents.Descendants))
-					{
-						BitSet descendants = relations.GetDescendants(dependency.GetItem1().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(dependency, ruleNames, ruleVersions, descendant
-								, "descendant");
-							highestRequiredDependency = Math.Max(highestRequiredDependency, required);
-						}
-					}
-					int declaredVersion = dependency.GetItem1().Version();
-					if (declaredVersion > highestRequiredDependency)
-					{
-						Tuple<IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty
-							(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
-						string message = string.Format("Rule dependency version mismatch: %s has maximum dependency version %d (expected %d) in %s"
-							, ruleNames[dependency.GetItem1().Rule()], highestRequiredDependency, declaredVersion
-							, GetRecognizerType(dependency.GetItem1()).ToString());
-						if (versionElement != null)
-						{
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
-								.GetItem2(), versionElement.GetItem1(), versionElement.GetItem2());
-						}
-						else
-						{
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
-								.GetItem2());
-						}
-					}
-				}
-				catch (AnnotationTypeMismatchException)
-				{
-					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, string.Format("Could not validate rule dependencies for element %s"
-						, dependency.GetItem2().ToString()), dependency.GetItem2());
-				}
-			}
-		}
+        private void CheckDependencies(IList<Tuple<RuleDependency, IElement>> dependencies
+            , ITypeMirror recognizerType)
+        {
+            string[] ruleNames = GetRuleNames(recognizerType);
+            int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
+            RuleDependencyProcessor.RuleRelations relations = ExtractRuleRelations(recognizerType
+                );
+            foreach (Tuple<RuleDependency, IElement> dependency in dependencies)
+            {
+                try
+                {
+                    if (!processingEnv.GetTypeUtils().IsAssignable(GetRecognizerType(dependency.GetItem1
+                        ()), recognizerType))
+                    {
+                        continue;
+                    }
+                    // this is the rule in the dependency set with the highest version number
+                    int effectiveRule = dependency.GetItem1().Rule();
+                    if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
+                    {
+                        Tuple<IAnnotationMirror, IAnnotationValue> ruleReferenceElement = FindRuleDependencyProperty
+                            (dependency, RuleDependencyProcessor.RuleDependencyProperty.Rule);
+                        string message = string.Format("Rule dependency on unknown rule %d@%d in %s", dependency
+                            .GetItem1().Rule(), dependency.GetItem1().Version(), GetRecognizerType(dependency
+                            .GetItem1()).ToString());
+                        if (ruleReferenceElement != null)
+                        {
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+                                .GetItem2(), ruleReferenceElement.GetItem1(), ruleReferenceElement.GetItem2()
+                                );
+                        }
+                        else
+                        {
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+                                .GetItem2());
+                        }
+                        continue;
+                    }
+                    EnumSet<Dependents> dependents = EnumSet.Of(Dependents.Self, dependency.GetItem1(
+                        ).Dependents());
+                    ReportUnimplementedDependents(dependency, dependents);
+                    BitSet checked = new BitSet();
+                    int highestRequiredDependency = CheckDependencyVersion(dependency, ruleNames, ruleVersions
+                        , effectiveRule, null);
+                    if (dependents.Contains(Dependents.Parents))
+                    {
+                        BitSet parents = relations.parents[dependency.GetItem1().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(dependency, ruleNames, ruleVersions, parent
+                                , "parent");
+                            highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                        }
+                    }
+                    if (dependents.Contains(Dependents.Children))
+                    {
+                        BitSet children = relations.children[dependency.GetItem1().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(dependency, ruleNames, ruleVersions, child, 
+                                "child");
+                            highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                        }
+                    }
+                    if (dependents.Contains(Dependents.Ancestors))
+                    {
+                        BitSet ancestors = relations.GetAncestors(dependency.GetItem1().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(dependency, ruleNames, ruleVersions, ancestor
+                                , "ancestor");
+                            highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                        }
+                    }
+                    if (dependents.Contains(Dependents.Descendants))
+                    {
+                        BitSet descendants = relations.GetDescendants(dependency.GetItem1().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(dependency, ruleNames, ruleVersions, descendant
+                                , "descendant");
+                            highestRequiredDependency = Math.Max(highestRequiredDependency, required);
+                        }
+                    }
+                    int declaredVersion = dependency.GetItem1().Version();
+                    if (declaredVersion > highestRequiredDependency)
+                    {
+                        Tuple<IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty
+                            (dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
+                        string message = string.Format("Rule dependency version mismatch: %s has maximum dependency version %d (expected %d) in %s"
+                            , ruleNames[dependency.GetItem1().Rule()], highestRequiredDependency, declaredVersion
+                            , GetRecognizerType(dependency.GetItem1()).ToString());
+                        if (versionElement != null)
+                        {
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+                                .GetItem2(), versionElement.GetItem1(), versionElement.GetItem2());
+                        }
+                        else
+                        {
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+                                .GetItem2());
+                        }
+                    }
+                }
+                catch (AnnotationTypeMismatchException)
+                {
+                    processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, string.Format("Could not validate rule dependencies for element %s"
+                        , dependency.GetItem2().ToString()), dependency.GetItem2());
+                }
+            }
+        }
 
-		private static readonly ICollection<Dependents> ImplementedDependents = EnumSet.Of
-			(Dependents.Self, Dependents.Parents, Dependents.Children, Dependents.Ancestors, 
-			Dependents.Descendants);
+        private static readonly ICollection<Dependents> ImplementedDependents = EnumSet.Of
+            (Dependents.Self, Dependents.Parents, Dependents.Children, Dependents.Ancestors
+            , Dependents.Descendants);
 
-		private void ReportUnimplementedDependents(Tuple<RuleDependency, IElement> dependency
-			, EnumSet<Dependents> dependents)
-		{
-			EnumSet<Dependents> unimplemented = dependents.Clone();
-			unimplemented.RemoveAll(ImplementedDependents);
-			if (!unimplemented.IsEmpty())
-			{
-				Tuple<IAnnotationMirror, IAnnotationValue> dependentsElement = FindRuleDependencyProperty
-					(dependency, RuleDependencyProcessor.RuleDependencyProperty.Dependents);
-				if (dependentsElement == null)
-				{
-					dependentsElement = FindRuleDependencyProperty(dependency, RuleDependencyProcessor.RuleDependencyProperty
-						.Rule);
-				}
-				string message = string.Format("Cannot validate the following dependents of rule %d: %s"
-					, dependency.GetItem1().Rule(), unimplemented);
-				if (dependentsElement != null)
-				{
-					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, message, dependency
-						.GetItem2(), dependentsElement.GetItem1(), dependentsElement.GetItem2());
-				}
-				else
-				{
-					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, message, dependency
-						.GetItem2());
-				}
-			}
-		}
+        private void ReportUnimplementedDependents(Tuple<RuleDependency, IElement> dependency
+            , EnumSet<Dependents> dependents)
+        {
+            EnumSet<Dependents> unimplemented = dependents.Clone();
+            unimplemented.RemoveAll(ImplementedDependents);
+            if (!unimplemented.IsEmpty())
+            {
+                Tuple<IAnnotationMirror, IAnnotationValue> dependentsElement = FindRuleDependencyProperty
+                    (dependency, RuleDependencyProcessor.RuleDependencyProperty.Dependents);
+                if (dependentsElement == null)
+                {
+                    dependentsElement = FindRuleDependencyProperty(dependency, RuleDependencyProcessor.RuleDependencyProperty
+                        .Rule);
+                }
+                string message = string.Format("Cannot validate the following dependents of rule %d: %s"
+                    , dependency.GetItem1().Rule(), unimplemented);
+                if (dependentsElement != null)
+                {
+                    processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, message, dependency
+                        .GetItem2(), dependentsElement.GetItem1(), dependentsElement.GetItem2());
+                }
+                else
+                {
+                    processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, message, dependency
+                        .GetItem2());
+                }
+            }
+        }
 
-		private int CheckDependencyVersion(Tuple<RuleDependency, IElement> dependency, string
-			[] ruleNames, int[] ruleVersions, int relatedRule, string relation)
-		{
-			string ruleName = ruleNames[dependency.GetItem1().Rule()];
-			string path;
-			if (relation == null)
-			{
-				path = ruleName;
-			}
-			else
-			{
-				string mismatchedRuleName = ruleNames[relatedRule];
-				path = string.Format("rule %s (%s of %s)", mismatchedRuleName, relation, ruleName
-					);
-			}
-			int declaredVersion = dependency.GetItem1().Version();
-			int actualVersion = ruleVersions[relatedRule];
-			if (actualVersion > declaredVersion)
-			{
-				Tuple<IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty
-					(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
-				string message = string.Format("Rule dependency version mismatch: %s has version %d (expected <= %d) in %s"
-					, path, actualVersion, declaredVersion, GetRecognizerType(dependency.GetItem1())
-					.ToString());
-				if (versionElement != null)
-				{
-					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
-						.GetItem2(), versionElement.GetItem1(), versionElement.GetItem2());
-				}
-				else
-				{
-					processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
-						.GetItem2());
-				}
-			}
-			return actualVersion;
-		}
+        private int CheckDependencyVersion(Tuple<RuleDependency, IElement> dependency, string
+            [] ruleNames, int[] ruleVersions, int relatedRule, string relation)
+        {
+            string ruleName = ruleNames[dependency.GetItem1().Rule()];
+            string path;
+            if (relation == null)
+            {
+                path = ruleName;
+            }
+            else
+            {
+                string mismatchedRuleName = ruleNames[relatedRule];
+                path = string.Format("rule %s (%s of %s)", mismatchedRuleName, relation, ruleName
+                    );
+            }
+            int declaredVersion = dependency.GetItem1().Version();
+            int actualVersion = ruleVersions[relatedRule];
+            if (actualVersion > declaredVersion)
+            {
+                Tuple<IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty
+                    (dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
+                string message = string.Format("Rule dependency version mismatch: %s has version %d (expected <= %d) in %s"
+                    , path, actualVersion, declaredVersion, GetRecognizerType(dependency.GetItem1
+                    ()).ToString());
+                if (versionElement != null)
+                {
+                    processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+                        .GetItem2(), versionElement.GetItem1(), versionElement.GetItem2());
+                }
+                else
+                {
+                    processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency
+                        .GetItem2());
+                }
+            }
+            return actualVersion;
+        }
 
-		private int[] GetRuleVersions(ITypeMirror recognizerClass, string[] ruleNames)
-		{
-			int[] versions = new int[ruleNames.Length];
-			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
-				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
-			foreach (IElement element in elements)
-			{
-				if (element.GetKind() != ElementKind.Field)
-				{
-					continue;
-				}
-				IVariableElement field = (IVariableElement)element;
-				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
-				object constantValue = field.GetConstantValue();
-				bool isInteger = constantValue is int;
-				string name = field.GetSimpleName().ToString();
-				if (isStatic && isInteger && name.StartsWith("RULE_"))
-				{
-					try
-					{
-						name = Sharpen.Runtime.Substring(name, "RULE_".Length);
-						if (name.IsEmpty() || !System.Char.IsLower(name[0]))
-						{
-							continue;
-						}
-						int index = (int)constantValue;
-						if (index < 0 || index >= versions.Length)
-						{
-							string message = string.Format("Rule index %d for rule '%s' out of bounds for recognizer %s."
-								, index, name, recognizerClass.ToString());
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
-							continue;
-						}
-						if (name.IndexOf(ATNSimulator.RuleVariantDelimiter) >= 0)
-						{
-							// ignore left-factored pseudo-rules
-							continue;
-						}
-						IExecutableElement ruleMethod = GetRuleMethod(recognizerClass, name);
-						if (ruleMethod == null)
-						{
-							string message = string.Format("Could not find rule method for rule '%s' in recognizer %s."
-								, name, recognizerClass.ToString());
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
-							continue;
-						}
-						RuleVersion ruleVersion = ruleMethod.GetAnnotation<RuleVersion>();
-						int version = ruleVersion != null ? ruleVersion.Value() : 0;
-						versions[index] = version;
-					}
-					catch (ArgumentException)
-					{
-						processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
-							, element);
-					}
-				}
-			}
-			return versions;
-		}
+        private int[] GetRuleVersions(ITypeMirror recognizerClass, string[] ruleNames)
+        {
+            int[] versions = new int[ruleNames.Length];
+            IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+                )processingEnv.GetTypeUtils().AsElement(recognizerClass));
+            foreach (IElement element in elements)
+            {
+                if (element.GetKind() != ElementKind.Field)
+                {
+                    continue;
+                }
+                IVariableElement field = (IVariableElement)element;
+                bool isStatic = element.GetModifiers().Contains(Modifier.Static);
+                object constantValue = field.GetConstantValue();
+                bool isInteger = constantValue is int;
+                string name = field.GetSimpleName().ToString();
+                if (isStatic && isInteger && name.StartsWith("RULE_"))
+                {
+                    try
+                    {
+                        name = Sharpen.Runtime.Substring(name, "RULE_".Length);
+                        if (name.IsEmpty() || !System.Char.IsLower(name[0]))
+                        {
+                            continue;
+                        }
+                        int index = (int)constantValue;
+                        if (index < 0 || index >= versions.Length)
+                        {
+                            string message = string.Format("Rule index %d for rule '%s' out of bounds for recognizer %s."
+                                , index, name, recognizerClass.ToString());
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
+                            continue;
+                        }
+                        if (name.IndexOf(ATNSimulator.RuleVariantDelimiter) >= 0)
+                        {
+                            // ignore left-factored pseudo-rules
+                            continue;
+                        }
+                        IExecutableElement ruleMethod = GetRuleMethod(recognizerClass, name);
+                        if (ruleMethod == null)
+                        {
+                            string message = string.Format("Could not find rule method for rule '%s' in recognizer %s."
+                                , name, recognizerClass.ToString());
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
+                            continue;
+                        }
+                        RuleVersion ruleVersion = ruleMethod.GetAnnotation<RuleVersion>();
+                        int version = ruleVersion != null ? ruleVersion.Value() : 0;
+                        versions[index] = version;
+                    }
+                    catch (ArgumentException)
+                    {
+                        processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
+                            , element);
+                    }
+                }
+            }
+            return versions;
+        }
 
-		private IExecutableElement GetRuleMethod(ITypeMirror recognizerClass, string name
-			)
-		{
-			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
-				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
-			foreach (IElement element in elements)
-			{
-				if (element.GetKind() != ElementKind.Method)
-				{
-					continue;
-				}
-				IExecutableElement method = (IExecutableElement)element;
-				if (method.GetSimpleName().ContentEquals(name) && HasRuleVersionAnnotation(method
-					))
-				{
-					return method;
-				}
-			}
-			return null;
-		}
+        private IExecutableElement GetRuleMethod(ITypeMirror recognizerClass, string name
+            )
+        {
+            IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+                )processingEnv.GetTypeUtils().AsElement(recognizerClass));
+            foreach (IElement element in elements)
+            {
+                if (element.GetKind() != ElementKind.Method)
+                {
+                    continue;
+                }
+                IExecutableElement method = (IExecutableElement)element;
+                if (method.GetSimpleName().ContentEquals(name) && HasRuleVersionAnnotation(method
+                    ))
+                {
+                    return method;
+                }
+            }
+            return null;
+        }
 
-		private bool HasRuleVersionAnnotation(IExecutableElement method)
-		{
-			ITypeElement ruleVersionAnnotationElement = processingEnv.GetElementUtils().GetTypeElement
-				(RuleVersionClassName);
-			if (ruleVersionAnnotationElement == null)
-			{
-				return false;
-			}
-			foreach (IAnnotationMirror annotation in method.GetAnnotationMirrors())
-			{
-				if (processingEnv.GetTypeUtils().IsSameType(annotation.GetAnnotationType(), ruleVersionAnnotationElement
-					.AsType()))
-				{
-					return true;
-				}
-			}
-			return false;
-		}
+        private bool HasRuleVersionAnnotation(IExecutableElement method)
+        {
+            ITypeElement ruleVersionAnnotationElement = processingEnv.GetElementUtils().GetTypeElement
+                (RuleVersionClassName);
+            if (ruleVersionAnnotationElement == null)
+            {
+                return false;
+            }
+            foreach (IAnnotationMirror annotation in method.GetAnnotationMirrors())
+            {
+                if (processingEnv.GetTypeUtils().IsSameType(annotation.GetAnnotationType(), ruleVersionAnnotationElement
+                    .AsType()))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
 
-		private string[] GetRuleNames(ITypeMirror recognizerClass)
-		{
-			IList<string> result = new List<string>();
-			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
-				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
-			foreach (IElement element in elements)
-			{
-				if (element.GetKind() != ElementKind.Field)
-				{
-					continue;
-				}
-				IVariableElement field = (IVariableElement)element;
-				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
-				object constantValue = field.GetConstantValue();
-				bool isInteger = constantValue is int;
-				string name = field.GetSimpleName().ToString();
-				if (isStatic && isInteger && name.StartsWith("RULE_"))
-				{
-					try
-					{
-						name = Sharpen.Runtime.Substring(name, "RULE_".Length);
-						if (name.IsEmpty() || !System.Char.IsLower(name[0]))
-						{
-							continue;
-						}
-						int index = (int)constantValue;
-						if (index < 0)
-						{
-							continue;
-						}
-						while (result.Count <= index)
-						{
-							result.AddItem(string.Empty);
-						}
-						result.Set(index, name);
-					}
-					catch (ArgumentException)
-					{
-						processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
-							, element);
-					}
-				}
-			}
-			return Sharpen.Collections.ToArray(result, new string[result.Count]);
-		}
+        private string[] GetRuleNames(ITypeMirror recognizerClass)
+        {
+            IList<string> result = new List<string>();
+            IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+                )processingEnv.GetTypeUtils().AsElement(recognizerClass));
+            foreach (IElement element in elements)
+            {
+                if (element.GetKind() != ElementKind.Field)
+                {
+                    continue;
+                }
+                IVariableElement field = (IVariableElement)element;
+                bool isStatic = element.GetModifiers().Contains(Modifier.Static);
+                object constantValue = field.GetConstantValue();
+                bool isInteger = constantValue is int;
+                string name = field.GetSimpleName().ToString();
+                if (isStatic && isInteger && name.StartsWith("RULE_"))
+                {
+                    try
+                    {
+                        name = Sharpen.Runtime.Substring(name, "RULE_".Length);
+                        if (name.IsEmpty() || !System.Char.IsLower(name[0]))
+                        {
+                            continue;
+                        }
+                        int index = (int)constantValue;
+                        if (index < 0)
+                        {
+                            continue;
+                        }
+                        while (result.Count <= index)
+                        {
+                            result.AddItem(string.Empty);
+                        }
+                        result.Set(index, name);
+                    }
+                    catch (ArgumentException)
+                    {
+                        processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
+                            , element);
+                    }
+                }
+            }
+            return Sharpen.Collections.ToArray(result, new string[result.Count]);
+        }
 
-		public static IList<Tuple<RuleDependency, IElement>> GetDependencies(IRoundEnvironment
-			 roundEnv)
-		{
-			IList<Tuple<RuleDependency, IElement>> result = new List<Tuple<RuleDependency, IElement
-				>>();
-			ICollection<IElement> elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependency
-				));
-			foreach (IElement element in elements)
-			{
-				RuleDependency dependency = element.GetAnnotation<RuleDependency>();
-				if (dependency == null)
-				{
-					continue;
-				}
-				result.AddItem(Tuple.Create(dependency, element));
-			}
-			elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependencies));
-			foreach (IElement element_1 in elements)
-			{
-				RuleDependencies dependencies = element_1.GetAnnotation<RuleDependencies>();
-				if (dependencies == null || dependencies.Value() == null)
-				{
-					continue;
-				}
-				foreach (RuleDependency dependency in dependencies.Value())
-				{
-					result.AddItem(Tuple.Create(dependency, element_1));
-				}
-			}
-			return result;
-		}
+        public static IList<Tuple<RuleDependency, IElement>> GetDependencies(IRoundEnvironment
+             roundEnv)
+        {
+            IList<Tuple<RuleDependency, IElement>> result = new List<Tuple<RuleDependency, IElement
+                >>();
+            ICollection<IElement> elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependency
+                ));
+            foreach (IElement element in elements)
+            {
+                RuleDependency dependency = element.GetAnnotation<RuleDependency>();
+                if (dependency == null)
+                {
+                    continue;
+                }
+                result.AddItem(Tuple.Create(dependency, element));
+            }
+            elements = roundEnv.GetElementsAnnotatedWith(typeof(RuleDependencies));
+            foreach (IElement element_1 in elements)
+            {
+                RuleDependencies dependencies = element_1.GetAnnotation<RuleDependencies>();
+                if (dependencies == null || dependencies.Value() == null)
+                {
+                    continue;
+                }
+                foreach (RuleDependency dependency in dependencies.Value())
+                {
+                    result.AddItem(Tuple.Create(dependency, element_1));
+                }
+            }
+            return result;
+        }
 
-		public enum RuleDependencyProperty
-		{
-			Recognizer,
-			Rule,
-			Version,
-			Dependents
-		}
+        public enum RuleDependencyProperty
+        {
+            Recognizer,
+            Rule,
+            Version,
+            Dependents
+        }
 
-		[Nullable]
-		private Tuple<IAnnotationMirror, IAnnotationValue> FindRuleDependencyProperty(Tuple
-			<RuleDependency, IElement> dependency, RuleDependencyProcessor.RuleDependencyProperty
-			 property)
-		{
-			ITypeElement ruleDependencyTypeElement = processingEnv.GetElementUtils().GetTypeElement
-				(RuleDependencyClassName);
-			ITypeElement ruleDependenciesTypeElement = processingEnv.GetElementUtils().GetTypeElement
-				(RuleDependenciesClassName);
-			IList<IAnnotationMirror> mirrors = dependency.GetItem2().GetAnnotationMirrors();
-			foreach (IAnnotationMirror annotationMirror in mirrors)
-			{
-				if (processingEnv.GetTypeUtils().IsSameType(ruleDependencyTypeElement.AsType(), annotationMirror
-					.GetAnnotationType()))
-				{
-					IAnnotationValue element = FindRuleDependencyProperty(dependency, annotationMirror
-						, property);
-					if (element != null)
-					{
-						return Tuple.Create(annotationMirror, element);
-					}
-				}
-				else
-				{
-					if (processingEnv.GetTypeUtils().IsSameType(ruleDependenciesTypeElement.AsType(), 
-						annotationMirror.GetAnnotationType()))
-					{
-						IDictionary<IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues
-							();
-						foreach (KeyValuePair<IExecutableElement, IAnnotationValue> value in values.EntrySet
-							())
-						{
-							if ("value()".Equals(value.Key.ToString()))
-							{
-								IAnnotationValue annotationValue = value.Value;
-								if (!(annotationValue.GetValue() is IList))
-								{
-									processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected array of RuleDependency annotations for annotation property 'value()'."
-										, dependency.GetItem2(), annotationMirror, annotationValue);
-									break;
-								}
-								IList<object> annotationValueList = (IList<object>)annotationValue.GetValue();
-								foreach (object obj in annotationValueList)
-								{
-									if (!(obj is IAnnotationMirror))
-									{
-										processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected RuleDependency annotation mirror for element of property 'value()'."
-											, dependency.GetItem2(), annotationMirror, annotationValue);
-										break;
-									}
-									IAnnotationValue element = FindRuleDependencyProperty(dependency, (IAnnotationMirror
-										)obj, property);
-									if (element != null)
-									{
-										return Tuple.Create((IAnnotationMirror)obj, element);
-									}
-								}
-							}
-							else
-							{
-								processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, string.Format("Unexpected annotation property %s."
-									, value.Key.ToString()), dependency.GetItem2(), annotationMirror, value.Value);
-							}
-						}
-					}
-				}
-			}
-			return null;
-		}
+        [Nullable]
+        private Tuple<IAnnotationMirror, IAnnotationValue> FindRuleDependencyProperty(Tuple
+            <RuleDependency, IElement> dependency, RuleDependencyProcessor.RuleDependencyProperty
+             property)
+        {
+            ITypeElement ruleDependencyTypeElement = processingEnv.GetElementUtils().GetTypeElement
+                (RuleDependencyClassName);
+            ITypeElement ruleDependenciesTypeElement = processingEnv.GetElementUtils().GetTypeElement
+                (RuleDependenciesClassName);
+            IList<IAnnotationMirror> mirrors = dependency.GetItem2().GetAnnotationMirrors();
+            foreach (IAnnotationMirror annotationMirror in mirrors)
+            {
+                if (processingEnv.GetTypeUtils().IsSameType(ruleDependencyTypeElement.AsType(), annotationMirror
+                    .GetAnnotationType()))
+                {
+                    IAnnotationValue element = FindRuleDependencyProperty(dependency, annotationMirror
+                        , property);
+                    if (element != null)
+                    {
+                        return Tuple.Create(annotationMirror, element);
+                    }
+                }
+                else
+                {
+                    if (processingEnv.GetTypeUtils().IsSameType(ruleDependenciesTypeElement.AsType(), 
+                        annotationMirror.GetAnnotationType()))
+                    {
+                        IDictionary<IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues
+                            ();
+                        foreach (KeyValuePair<IExecutableElement, IAnnotationValue> value in values.EntrySet
+                            ())
+                        {
+                            if ("value()".Equals(value.Key.ToString()))
+                            {
+                                IAnnotationValue annotationValue = value.Value;
+                                if (!(annotationValue.GetValue() is IList))
+                                {
+                                    processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected array of RuleDependency annotations for annotation property 'value()'."
+                                        , dependency.GetItem2(), annotationMirror, annotationValue);
+                                    break;
+                                }
+                                IList<object> annotationValueList = (IList<object>)annotationValue.GetValue();
+                                foreach (object obj in annotationValueList)
+                                {
+                                    if (!(obj is IAnnotationMirror))
+                                    {
+                                        processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected RuleDependency annotation mirror for element of property 'value()'."
+                                            , dependency.GetItem2(), annotationMirror, annotationValue);
+                                        break;
+                                    }
+                                    IAnnotationValue element = FindRuleDependencyProperty(dependency, (IAnnotationMirror
+                                        )obj, property);
+                                    if (element != null)
+                                    {
+                                        return Tuple.Create((IAnnotationMirror)obj, element);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, string.Format("Unexpected annotation property %s."
+                                    , value.Key.ToString()), dependency.GetItem2(), annotationMirror, value.Value
+                                    );
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
 
-		[Nullable]
-		private IAnnotationValue FindRuleDependencyProperty(Tuple<RuleDependency, IElement
-			> dependency, IAnnotationMirror annotationMirror, RuleDependencyProcessor.RuleDependencyProperty
-			 property)
-		{
-			IAnnotationValue recognizerValue = null;
-			IAnnotationValue ruleValue = null;
-			IAnnotationValue versionValue = null;
-			IAnnotationValue dependentsValue = null;
-			IDictionary<IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues
-				();
-			foreach (KeyValuePair<IExecutableElement, IAnnotationValue> value in values.EntrySet
-				())
-			{
-				IAnnotationValue annotationValue = value.Value;
-				if ("rule()".Equals(value.Key.ToString()))
-				{
-					ruleValue = annotationValue;
-					if (!(annotationValue.GetValue() is int))
-					{
-						processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'rule()'."
-							, dependency.GetItem2(), annotationMirror, annotationValue);
-						return null;
-					}
-					if ((int)annotationValue.GetValue() != dependency.GetItem1().Rule())
-					{
-						// this is a valid dependency annotation, but not the one we're looking for
-						return null;
-					}
-				}
-				else
-				{
-					if ("recognizer()".Equals(value.Key.ToString()))
-					{
-						recognizerValue = annotationValue;
-						if (!(annotationValue.GetValue() is ITypeMirror))
-						{
-							processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected Class constant for annotation property 'recognizer()'."
-								, dependency.GetItem2(), annotationMirror, annotationValue);
-							return null;
-						}
-						ITypeMirror annotationRecognizer = (ITypeMirror)annotationValue.GetValue();
-						ITypeMirror expectedRecognizer = GetRecognizerType(dependency.GetItem1());
-						if (!processingEnv.GetTypeUtils().IsSameType(expectedRecognizer, annotationRecognizer
-							))
-						{
-							// this is a valid dependency annotation, but not the one we're looking for
-							return null;
-						}
-					}
-					else
-					{
-						if ("version()".Equals(value.Key.ToString()))
-						{
-							versionValue = annotationValue;
-							if (!(annotationValue.GetValue() is int))
-							{
-								processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'version()'."
-									, dependency.GetItem2(), annotationMirror, annotationValue);
-								return null;
-							}
-							if ((int)annotationValue.GetValue() != dependency.GetItem1().Version())
-							{
-								// this is a valid dependency annotation, but not the one we're looking for
-								return null;
-							}
-						}
-					}
-				}
-			}
-			if (recognizerValue != null)
-			{
-				if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
-				{
-					return recognizerValue;
-				}
-				else
-				{
-					if (ruleValue != null)
-					{
-						if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
-						{
-							return ruleValue;
-						}
-						else
-						{
-							if (versionValue != null)
-							{
-								if (property == RuleDependencyProcessor.RuleDependencyProperty.Version)
-								{
-									return versionValue;
-								}
-								else
-								{
-									if (property == RuleDependencyProcessor.RuleDependencyProperty.Dependents)
-									{
-										return dependentsValue;
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-			if (recognizerValue == null)
-			{
-				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'recognizer()' element in annotation."
-					, dependency.GetItem2(), annotationMirror);
-			}
-			if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
-			{
-				return null;
-			}
-			if (ruleValue == null)
-			{
-				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'rule()' element in annotation."
-					, dependency.GetItem2(), annotationMirror);
-			}
-			if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
-			{
-				return null;
-			}
-			if (versionValue == null)
-			{
-				processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'version()' element in annotation."
-					, dependency.GetItem2(), annotationMirror);
-			}
-			return null;
-		}
+        [Nullable]
+        private IAnnotationValue FindRuleDependencyProperty(Tuple<RuleDependency, IElement
+            > dependency, IAnnotationMirror annotationMirror, RuleDependencyProcessor.RuleDependencyProperty
+             property)
+        {
+            IAnnotationValue recognizerValue = null;
+            IAnnotationValue ruleValue = null;
+            IAnnotationValue versionValue = null;
+            IAnnotationValue dependentsValue = null;
+            IDictionary<IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues
+                ();
+            foreach (KeyValuePair<IExecutableElement, IAnnotationValue> value in values.EntrySet
+                ())
+            {
+                IAnnotationValue annotationValue = value.Value;
+                if ("rule()".Equals(value.Key.ToString()))
+                {
+                    ruleValue = annotationValue;
+                    if (!(annotationValue.GetValue() is int))
+                    {
+                        processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'rule()'."
+                            , dependency.GetItem2(), annotationMirror, annotationValue);
+                        return null;
+                    }
+                    if ((int)annotationValue.GetValue() != dependency.GetItem1().Rule())
+                    {
+                        // this is a valid dependency annotation, but not the one we're looking for
+                        return null;
+                    }
+                }
+                else
+                {
+                    if ("recognizer()".Equals(value.Key.ToString()))
+                    {
+                        recognizerValue = annotationValue;
+                        if (!(annotationValue.GetValue() is ITypeMirror))
+                        {
+                            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected Class constant for annotation property 'recognizer()'."
+                                , dependency.GetItem2(), annotationMirror, annotationValue);
+                            return null;
+                        }
+                        ITypeMirror annotationRecognizer = (ITypeMirror)annotationValue.GetValue();
+                        ITypeMirror expectedRecognizer = GetRecognizerType(dependency.GetItem1());
+                        if (!processingEnv.GetTypeUtils().IsSameType(expectedRecognizer, annotationRecognizer
+                            ))
+                        {
+                            // this is a valid dependency annotation, but not the one we're looking for
+                            return null;
+                        }
+                    }
+                    else
+                    {
+                        if ("version()".Equals(value.Key.ToString()))
+                        {
+                            versionValue = annotationValue;
+                            if (!(annotationValue.GetValue() is int))
+                            {
+                                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'version()'."
+                                    , dependency.GetItem2(), annotationMirror, annotationValue);
+                                return null;
+                            }
+                            if ((int)annotationValue.GetValue() != dependency.GetItem1().Version())
+                            {
+                                // this is a valid dependency annotation, but not the one we're looking for
+                                return null;
+                            }
+                        }
+                    }
+                }
+            }
+            if (recognizerValue != null)
+            {
+                if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
+                {
+                    return recognizerValue;
+                }
+                else
+                {
+                    if (ruleValue != null)
+                    {
+                        if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
+                        {
+                            return ruleValue;
+                        }
+                        else
+                        {
+                            if (versionValue != null)
+                            {
+                                if (property == RuleDependencyProcessor.RuleDependencyProperty.Version)
+                                {
+                                    return versionValue;
+                                }
+                                else
+                                {
+                                    if (property == RuleDependencyProcessor.RuleDependencyProperty.Dependents)
+                                    {
+                                        return dependentsValue;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (recognizerValue == null)
+            {
+                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'recognizer()' element in annotation."
+                    , dependency.GetItem2(), annotationMirror);
+            }
+            if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
+            {
+                return null;
+            }
+            if (ruleValue == null)
+            {
+                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'rule()' element in annotation."
+                    , dependency.GetItem2(), annotationMirror);
+            }
+            if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
+            {
+                return null;
+            }
+            if (versionValue == null)
+            {
+                processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'version()' element in annotation."
+                    , dependency.GetItem2(), annotationMirror);
+            }
+            return null;
+        }
 
-		private RuleDependencyProcessor.RuleRelations ExtractRuleRelations(ITypeMirror recognizer
-			)
-		{
-			string serializedATN = GetSerializedATN(recognizer);
-			if (serializedATN == null)
-			{
-				return null;
-			}
-			ATN atn = ATNSimulator.Deserialize(serializedATN.ToCharArray());
-			RuleDependencyProcessor.RuleRelations relations = new RuleDependencyProcessor.RuleRelations
-				(atn.ruleToStartState.Length);
-			foreach (ATNState state in atn.states)
-			{
-				if (!state.epsilonOnlyTransitions)
-				{
-					continue;
-				}
-				foreach (Transition transition in state.GetTransitions())
-				{
-					if (transition.SerializationType != Transition.Rule)
-					{
-						continue;
-					}
-					RuleTransition ruleTransition = (RuleTransition)transition;
-					relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
-				}
-			}
-			return relations;
-		}
+        private RuleDependencyProcessor.RuleRelations ExtractRuleRelations(ITypeMirror recognizer
+            )
+        {
+            string serializedATN = GetSerializedATN(recognizer);
+            if (serializedATN == null)
+            {
+                return null;
+            }
+            ATN atn = ATNSimulator.Deserialize(serializedATN.ToCharArray());
+            RuleDependencyProcessor.RuleRelations relations = new RuleDependencyProcessor.RuleRelations
+                (atn.ruleToStartState.Length);
+            foreach (ATNState state in atn.states)
+            {
+                if (!state.epsilonOnlyTransitions)
+                {
+                    continue;
+                }
+                foreach (Transition transition in state.GetTransitions())
+                {
+                    if (transition.SerializationType != Transition.Rule)
+                    {
+                        continue;
+                    }
+                    RuleTransition ruleTransition = (RuleTransition)transition;
+                    relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
+                }
+            }
+            return relations;
+        }
 
-		private string GetSerializedATN(ITypeMirror recognizerClass)
-		{
-			IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
-				)processingEnv.GetTypeUtils().AsElement(recognizerClass));
-			foreach (IElement element in elements)
-			{
-				if (element.GetKind() != ElementKind.Field)
-				{
-					continue;
-				}
-				IVariableElement field = (IVariableElement)element;
-				bool isStatic = element.GetModifiers().Contains(Modifier.Static);
-				object constantValue = field.GetConstantValue();
-				bool isString = constantValue is string;
-				string name = field.GetSimpleName().ToString();
-				if (isStatic && isString && name.Equals("_serializedATN"))
-				{
-					return (string)constantValue;
-				}
-			}
-			processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Could not retrieve serialized ATN from grammar."
-				);
-			return null;
-		}
+        private string GetSerializedATN(ITypeMirror recognizerClass)
+        {
+            IList<IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
+                )processingEnv.GetTypeUtils().AsElement(recognizerClass));
+            foreach (IElement element in elements)
+            {
+                if (element.GetKind() != ElementKind.Field)
+                {
+                    continue;
+                }
+                IVariableElement field = (IVariableElement)element;
+                bool isStatic = element.GetModifiers().Contains(Modifier.Static);
+                object constantValue = field.GetConstantValue();
+                bool isString = constantValue is string;
+                string name = field.GetSimpleName().ToString();
+                if (isStatic && isString && name.Equals("_serializedATN"))
+                {
+                    return (string)constantValue;
+                }
+            }
+            processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Could not retrieve serialized ATN from grammar."
+                );
+            return null;
+        }
 
-		private sealed class RuleRelations
-		{
-			private readonly BitSet[] parents;
+        private sealed class RuleRelations
+        {
+            private readonly BitSet[] parents;
 
-			private readonly BitSet[] children;
+            private 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 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 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 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;
-			}
-		}
-	}
+            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;
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/TestRig.cs b/Antlr4.Runtime/Misc/TestRig.cs
index 05c883d61..00f94c54a 100644
--- a/Antlr4.Runtime/Misc/TestRig.cs
+++ b/Antlr4.Runtime/Misc/TestRig.cs
@@ -38,300 +38,300 @@ using Sharpen.Reflect;
 
 namespace Antlr4.Runtime.Misc
 {
-	/// <summary>
-	/// Run a lexer/parser combo, optionally printing tree string or generating
-	/// postscript file.
-	/// </summary>
-	/// <remarks>
-	/// 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)]
-	/// </remarks>
-	public class TestRig
-	{
-		public static readonly string LexerStartRuleName = "tokens";
+    /// <summary>
+    /// Run a lexer/parser combo, optionally printing tree string or generating
+    /// postscript file.
+    /// </summary>
+    /// <remarks>
+    /// 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)]
+    /// </remarks>
+    public class TestRig
+    {
+        public static readonly string LexerStartRuleName = "tokens";
 
-		protected internal string grammarName;
+        protected internal string grammarName;
 
-		protected internal string startRuleName;
+        protected internal string startRuleName;
 
-		protected internal readonly IList<string> inputFiles = new List<string>();
+        protected internal readonly IList<string> inputFiles = new List<string>();
 
-		protected internal bool printTree = false;
+        protected internal bool printTree = false;
 
-		protected internal bool gui = false;
+        protected internal bool gui = false;
 
-		protected internal string psFile = null;
+        protected internal string psFile = null;
 
-		protected internal bool showTokens = false;
+        protected internal bool showTokens = false;
 
-		protected internal bool trace = false;
+        protected internal bool trace = false;
 
-		protected internal bool diagnostics = false;
+        protected internal bool diagnostics = false;
 
-		protected internal string encoding = null;
+        protected internal string encoding = null;
 
-		protected internal bool Sll = false;
+        protected internal bool Sll = false;
 
-		/// <exception cref="System.Exception"></exception>
-		public TestRig(string[] args)
-		{
-			if (args.Length < 2)
-			{
-				System.Console.Error.WriteLine("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.Console.Error.WriteLine("Use startRuleName='tokens' if GrammarName is a lexer grammar."
-					);
-				System.Console.Error.WriteLine("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[0] != '-')
-				{
-					// input file name
-					inputFiles.AddItem(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.Console.Error.WriteLine("missing encoding on -encoding");
-										return;
-									}
-									encoding = args[i];
-									i++;
-								}
-								else
-								{
-									if (arg.Equals("-ps"))
-									{
-										if (i >= args.Length)
-										{
-											System.Console.Error.WriteLine("missing filename on -ps");
-											return;
-										}
-										psFile = args[i];
-										i++;
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
+        /// <exception cref="System.Exception"></exception>
+        public TestRig(string[] args)
+        {
+            if (args.Length < 2)
+            {
+                System.Console.Error.WriteLine("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.Console.Error.WriteLine("Use startRuleName='tokens' if GrammarName is a lexer grammar."
+                    );
+                System.Console.Error.WriteLine("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[0] != '-')
+                {
+                    // input file name
+                    inputFiles.AddItem(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.Console.Error.WriteLine("missing encoding on -encoding");
+                                        return;
+                                    }
+                                    encoding = args[i];
+                                    i++;
+                                }
+                                else
+                                {
+                                    if (arg.Equals("-ps"))
+                                    {
+                                        if (i >= args.Length)
+                                        {
+                                            System.Console.Error.WriteLine("missing filename on -ps");
+                                            return;
+                                        }
+                                        psFile = args[i];
+                                        i++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
 
-		/// <exception cref="System.Exception"></exception>
-		public static void Main(string[] args)
-		{
-			Antlr4.Runtime.Misc.TestRig testRig = new Antlr4.Runtime.Misc.TestRig(args);
-			testRig.Process();
-		}
+        /// <exception cref="System.Exception"></exception>
+        public static void Main(string[] args)
+        {
+            Antlr4.Runtime.Misc.TestRig testRig = new Antlr4.Runtime.Misc.TestRig(args);
+            testRig.Process();
+        }
 
-		/// <exception cref="System.Exception"></exception>
-		public virtual void Process()
-		{
-			//		System.out.println("exec "+grammarName+"."+startRuleName);
-			string lexerName = grammarName + "Lexer";
-			ClassLoader cl = Sharpen.Thread.CurrentThread().GetContextClassLoader();
-			Type lexerClass = null;
-			try
-			{
-				lexerClass = cl.LoadClass(lexerName).AsSubclass<Lexer>();
-			}
-			catch (TypeLoadException)
-			{
-				// might be pure lexer grammar; no Lexer suffix then
-				lexerName = grammarName;
-				try
-				{
-					lexerClass = cl.LoadClass(lexerName).AsSubclass<Lexer>();
-				}
-				catch (TypeLoadException)
-				{
-					System.Console.Error.WriteLine("Can't load " + lexerName + " as lexer or parser");
-					return;
-				}
-			}
-			Constructor<Lexer> lexerCtor = lexerClass.GetConstructor(typeof(ICharStream));
-			Lexer lexer = lexerCtor.NewInstance((ICharStream)null);
-			Type parserClass = null;
-			Parser parser = null;
-			if (!startRuleName.Equals(LexerStartRuleName))
-			{
-				string parserName = grammarName + "Parser";
-				parserClass = (Type)cl.LoadClass(parserName).AsSubclass<Parser>();
-				if (parserClass == null)
-				{
-					System.Console.Error.WriteLine("Can't load " + parserName);
-				}
-				Constructor<Parser> parserCtor = parserClass.GetConstructor(typeof(ITokenStream));
-				parser = parserCtor.NewInstance((ITokenStream)null);
-			}
-			if (inputFiles.IsEmpty())
-			{
-				InputStream @is = Sharpen.Runtime.@in;
-				StreamReader r;
-				if (encoding != null)
-				{
-					r = new InputStreamReader(@is, encoding);
-				}
-				else
-				{
-					r = new InputStreamReader(@is);
-				}
-				Process(lexer, parserClass, parser, @is, r);
-				return;
-			}
-			foreach (string inputFile in inputFiles)
-			{
-				InputStream @is = Sharpen.Runtime.@in;
-				if (inputFile != null)
-				{
-					@is = new FileInputStream(inputFile);
-				}
-				StreamReader r;
-				if (encoding != null)
-				{
-					r = new InputStreamReader(@is, encoding);
-				}
-				else
-				{
-					r = new InputStreamReader(@is);
-				}
-				if (inputFiles.Count > 1)
-				{
-					System.Console.Error.WriteLine(inputFile);
-				}
-				Process(lexer, parserClass, parser, @is, r);
-			}
-		}
+        /// <exception cref="System.Exception"></exception>
+        public virtual void Process()
+        {
+            //		System.out.println("exec "+grammarName+"."+startRuleName);
+            string lexerName = grammarName + "Lexer";
+            ClassLoader cl = Sharpen.Thread.CurrentThread().GetContextClassLoader();
+            Type lexerClass = null;
+            try
+            {
+                lexerClass = cl.LoadClass(lexerName).AsSubclass<Lexer>();
+            }
+            catch (TypeLoadException)
+            {
+                // might be pure lexer grammar; no Lexer suffix then
+                lexerName = grammarName;
+                try
+                {
+                    lexerClass = cl.LoadClass(lexerName).AsSubclass<Lexer>();
+                }
+                catch (TypeLoadException)
+                {
+                    System.Console.Error.WriteLine("Can't load " + lexerName + " as lexer or parser");
+                    return;
+                }
+            }
+            Constructor<Lexer> lexerCtor = lexerClass.GetConstructor(typeof(ICharStream));
+            Lexer lexer = lexerCtor.NewInstance((ICharStream)null);
+            Type parserClass = null;
+            Parser parser = null;
+            if (!startRuleName.Equals(LexerStartRuleName))
+            {
+                string parserName = grammarName + "Parser";
+                parserClass = (Type)cl.LoadClass(parserName).AsSubclass<Parser>();
+                if (parserClass == null)
+                {
+                    System.Console.Error.WriteLine("Can't load " + parserName);
+                }
+                Constructor<Parser> parserCtor = parserClass.GetConstructor(typeof(ITokenStream));
+                parser = parserCtor.NewInstance((ITokenStream)null);
+            }
+            if (inputFiles.IsEmpty())
+            {
+                InputStream @is = Sharpen.Runtime.@in;
+                StreamReader r;
+                if (encoding != null)
+                {
+                    r = new InputStreamReader(@is, encoding);
+                }
+                else
+                {
+                    r = new InputStreamReader(@is);
+                }
+                Process(lexer, parserClass, parser, @is, r);
+                return;
+            }
+            foreach (string inputFile in inputFiles)
+            {
+                InputStream @is = Sharpen.Runtime.@in;
+                if (inputFile != null)
+                {
+                    @is = new FileInputStream(inputFile);
+                }
+                StreamReader r;
+                if (encoding != null)
+                {
+                    r = new InputStreamReader(@is, encoding);
+                }
+                else
+                {
+                    r = new InputStreamReader(@is);
+                }
+                if (inputFiles.Count > 1)
+                {
+                    System.Console.Error.WriteLine(inputFile);
+                }
+                Process(lexer, parserClass, parser, @is, r);
+            }
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		/// <exception cref="System.MemberAccessException"></exception>
-		/// <exception cref="System.Reflection.TargetInvocationException"></exception>
-		/// <exception cref="Javax.Print.PrintException"></exception>
-		protected internal virtual void Process<_T0>(Lexer lexer, Type<_T0> parserClass, 
-			Parser parser, InputStream @is, StreamReader r) where _T0:Parser
-		{
-			try
-			{
-				AntlrInputStream input = new AntlrInputStream(r);
-				lexer.SetInputStream(input);
-				CommonTokenStream tokens = new CommonTokenStream(lexer);
-				tokens.Fill();
-				if (showTokens)
-				{
-					foreach (object tok in tokens.GetTokens())
-					{
-						System.Console.Out.WriteLine(tok);
-					}
-				}
-				if (startRuleName.Equals(LexerStartRuleName))
-				{
-					return;
-				}
-				if (diagnostics)
-				{
-					parser.AddErrorListener(new DiagnosticErrorListener());
-					parser.GetInterpreter().SetPredictionMode(PredictionMode.LlExactAmbigDetection);
-				}
-				if (printTree || gui || psFile != null)
-				{
-					parser.SetBuildParseTree(true);
-				}
-				if (Sll)
-				{
-					// overrides diagnostics
-					parser.GetInterpreter().SetPredictionMode(PredictionMode.Sll);
-				}
-				parser.SetInputStream(tokens);
-				parser.SetTrace(trace);
-				try
-				{
-					MethodInfo startRule = parserClass.GetMethod(startRuleName, (Type[])null);
-					ParserRuleContext tree = (ParserRuleContext)startRule.Invoke(parser, (object[])null
-						);
-					if (printTree)
-					{
-						System.Console.Out.WriteLine(tree.ToStringTree(parser));
-					}
-					if (gui)
-					{
-						tree.Inspect(parser);
-					}
-					if (psFile != null)
-					{
-						tree.Save(parser, psFile);
-					}
-				}
-				catch (NoSuchMethodException)
-				{
-					// Generate postscript
-					System.Console.Error.WriteLine("No method for rule " + startRuleName + " or it has arguments"
-						);
-				}
-			}
-			finally
-			{
-				if (r != null)
-				{
-					r.Close();
-				}
-				if (@is != null)
-				{
-					@is.Close();
-				}
-			}
-		}
-	}
+        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="System.MemberAccessException"></exception>
+        /// <exception cref="System.Reflection.TargetInvocationException"></exception>
+        /// <exception cref="Javax.Print.PrintException"></exception>
+        protected internal virtual void Process<_T0>(Lexer lexer, Type<_T0> parserClass, 
+            Parser parser, InputStream @is, StreamReader r) where _T0:Parser
+        {
+            try
+            {
+                AntlrInputStream input = new AntlrInputStream(r);
+                lexer.SetInputStream(input);
+                CommonTokenStream tokens = new CommonTokenStream(lexer);
+                tokens.Fill();
+                if (showTokens)
+                {
+                    foreach (object tok in tokens.GetTokens())
+                    {
+                        System.Console.Out.WriteLine(tok);
+                    }
+                }
+                if (startRuleName.Equals(LexerStartRuleName))
+                {
+                    return;
+                }
+                if (diagnostics)
+                {
+                    parser.AddErrorListener(new DiagnosticErrorListener());
+                    parser.GetInterpreter().SetPredictionMode(PredictionMode.LlExactAmbigDetection);
+                }
+                if (printTree || gui || psFile != null)
+                {
+                    parser.SetBuildParseTree(true);
+                }
+                if (Sll)
+                {
+                    // overrides diagnostics
+                    parser.GetInterpreter().SetPredictionMode(PredictionMode.Sll);
+                }
+                parser.SetInputStream(tokens);
+                parser.SetTrace(trace);
+                try
+                {
+                    MethodInfo startRule = parserClass.GetMethod(startRuleName, (Type[])null);
+                    ParserRuleContext tree = (ParserRuleContext)startRule.Invoke(parser, (object[])null
+                        );
+                    if (printTree)
+                    {
+                        System.Console.Out.WriteLine(tree.ToStringTree(parser));
+                    }
+                    if (gui)
+                    {
+                        tree.Inspect(parser);
+                    }
+                    if (psFile != null)
+                    {
+                        tree.Save(parser, psFile);
+                    }
+                }
+                catch (NoSuchMethodException)
+                {
+                    // Generate postscript
+                    System.Console.Error.WriteLine("No method for rule " + startRuleName + " or it has arguments"
+                        );
+                }
+            }
+            finally
+            {
+                if (r != null)
+                {
+                    r.Close();
+                }
+                if (@is != null)
+                {
+                    @is.Close();
+                }
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Misc/Utils.cs b/Antlr4.Runtime/Misc/Utils.cs
index e02f941a2..45d6e1ee3 100644
--- a/Antlr4.Runtime/Misc/Utils.cs
+++ b/Antlr4.Runtime/Misc/Utils.cs
@@ -34,112 +34,112 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Misc
 {
-	public class Utils
-	{
-		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 class Utils
+    {
+        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 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 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, _T1>(IList<T> list, IPredicate<_T1> predicate)
-		{
-			int j = 0;
-			for (int i = 0; i < list.Count; i++)
-			{
-				T item = list[i];
-				if (!predicate.Eval(item))
-				{
-					if (j != i)
-					{
-						list.Set(j, item);
-					}
-					j++;
-				}
-			}
-			if (j < list.Count)
-			{
-				list.SubList(j, list.Count).Clear();
-			}
-		}
+        public static void RemoveAll<T, _T1>(IList<T> list, IPredicate<_T1> predicate)
+        {
+            int j = 0;
+            for (int i = 0; i < list.Count; i++)
+            {
+                T item = list[i];
+                if (!predicate.Eval(item))
+                {
+                    if (j != i)
+                    {
+                        list.Set(j, item);
+                    }
+                    j++;
+                }
+            }
+            if (j < list.Count)
+            {
+                list.SubList(j, list.Count).Clear();
+            }
+        }
 
-		public static void RemoveAll<T, _T1>(IEnumerable<T> iterable, IPredicate<_T1> predicate
-			)
-		{
-			if (iterable is IList<object>)
-			{
-				RemoveAll((IList<T>)iterable, predicate);
-				return;
-			}
-			for (IEnumerator<T> iterator = iterable.GetEnumerator(); iterator.HasNext(); )
-			{
-				T item = iterator.Next();
-				if (predicate.Eval(item))
-				{
-					iterator.Remove();
-				}
-			}
-		}
-	}
+        public static void RemoveAll<T, _T1>(IEnumerable<T> iterable, IPredicate<_T1> predicate
+            )
+        {
+            if (iterable is IList<object>)
+            {
+                RemoveAll((IList<T>)iterable, predicate);
+                return;
+            }
+            for (IEnumerator<T> iterator = iterable.GetEnumerator(); iterator.HasNext(); )
+            {
+                T item = iterator.Next();
+                if (predicate.Eval(item))
+                {
+                    iterator.Remove();
+                }
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/NoViableAltException.cs b/Antlr4.Runtime/NoViableAltException.cs
index 828809554..ecb6be5de 100644
--- a/Antlr4.Runtime/NoViableAltException.cs
+++ b/Antlr4.Runtime/NoViableAltException.cs
@@ -34,64 +34,64 @@ using 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>
+    /// 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>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;
+        /// <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.GetInputStream()), recognizer.GetCurrentToken(), recognizer.GetCurrentToken
-			(), null, recognizer._ctx)
-		{
-		}
+        public NoViableAltException(Parser recognizer) : this(recognizer, ((ITokenStream)
+            recognizer.GetInputStream()), recognizer.GetCurrentToken(), recognizer.GetCurrentToken
+            (), null, recognizer._ctx)
+        {
+        }
 
-		public NoViableAltException(Recognizer<IToken, object> 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.SetOffendingToken(offendingToken);
-		}
+        public NoViableAltException(Recognizer<IToken, object> 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.SetOffendingToken(offendingToken);
+        }
 
-		public virtual IToken GetStartToken()
-		{
-			return startToken;
-		}
+        public virtual IToken GetStartToken()
+        {
+            return startToken;
+        }
 
-		[Nullable]
-		public virtual ATNConfigSet GetDeadEndConfigs()
-		{
-			return deadEndConfigs;
-		}
-	}
+        [Nullable]
+        public virtual ATNConfigSet GetDeadEndConfigs()
+        {
+            return deadEndConfigs;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Parser.cs b/Antlr4.Runtime/Parser.cs
index 562c0205a..97908fc75 100644
--- a/Antlr4.Runtime/Parser.cs
+++ b/Antlr4.Runtime/Parser.cs
@@ -38,885 +38,885 @@ using Sharpen;
 
 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>
-	{
-		public class TraceListener : IParseTreeListener
-		{
-			public virtual void EnterEveryRule(ParserRuleContext ctx)
-			{
-				System.Console.Out.WriteLine("enter   " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
-					()] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
-			}
-
-			public virtual void ExitEveryRule(ParserRuleContext ctx)
-			{
-				System.Console.Out.WriteLine("exit    " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
-					()] + ", 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.GetRuleNames
-					()[parent.GetRuleIndex()] + " alt=" + parent.altNum);
-			}
-
-			internal TraceListener(Parser _enclosing)
-			{
-				this._enclosing = _enclosing;
-			}
-
-			private readonly Parser _enclosing;
-		}
-
-		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 ArrayList)
-				{
-					((List<object>)ctx.children).TrimToSize();
-				}
-			}
-		}
-
-		protected internal IAntlrErrorStrategy _errHandler = new DefaultErrorStrategy();
-
-		protected internal ITokenStream _input;
-
-		protected internal readonly IntegerStack _precedenceStack;
-
-		/// <summary>The RuleContext object for the currently executing rule.</summary>
-		/// <remarks>
-		/// The RuleContext object for the currently executing rule. This
-		/// must be non-null during parsing, but is initially null.
-		/// When somebody calls the start rule, this gets set to the
-		/// root context.
-		/// </remarks>
-		protected internal ParserRuleContext _ctx;
-
-		protected internal bool _buildParseTrees = true;
-
-		protected internal Parser.TraceListener _tracer;
-
-		/// <summary>
-		/// If the listener is non-null, trigger enter and exit rule events
-		/// *during* the parse.
-		/// </summary>
-		/// <remarks>
-		/// If the listener is non-null, trigger enter and exit rule events
-		/// *during* the parse. This is typically done only when not building
-		/// parse trees for later visiting. We either trigger events during
-		/// the parse or during tree walks later. Both could be done.
-		/// Not intended for average user!!!  Most people should use
-		/// ParseTreeListener with ParseTreeWalker.
-		/// </remarks>
-		/// <seealso cref="Antlr4.Runtime.Tree.ParseTreeWalker">Antlr4.Runtime.Tree.ParseTreeWalker
-		/// 	</seealso>
-		protected internal IList<IParseTreeListener> _parseListeners;
-
-		/// <summary>Did the recognizer encounter a syntax error?  Track how many.</summary>
-		/// <remarks>Did the recognizer encounter a syntax error?  Track how many.</remarks>
-		protected internal int _syntaxErrors = 0;
-
-		public Parser(ITokenStream input)
-		{
-			{
-				_precedenceStack = new IntegerStack();
-				_precedenceStack.Push(0);
-			}
-			SetInputStream(input);
-		}
-
-		/// <summary>reset the parser's state</summary>
-		public virtual void Reset()
-		{
-			if (((ITokenStream)GetInputStream()) != null)
-			{
-				((ITokenStream)GetInputStream()).Seek(0);
-			}
-			_errHandler.EndErrorCondition(this);
-			_ctx = null;
-			_syntaxErrors = 0;
-			_tracer = null;
-			_precedenceStack.Clear();
-			_precedenceStack.Push(0);
-			ATNSimulator interpreter = GetInterpreter();
-			if (interpreter != null)
-			{
-				interpreter.Reset();
-			}
-		}
-
-		/// <summary>Match current input symbol against ttype.</summary>
-		/// <remarks>
-		/// Match current input symbol against ttype.  Attempt
-		/// single token insertion or deletion error recovery.  If
-		/// that fails, throw MismatchedTokenException.
-		/// </remarks>
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual IToken Match(int ttype)
-		{
-			IToken t = GetCurrentToken();
-			if (t.Type == ttype)
-			{
-				_errHandler.EndErrorCondition(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;
-		}
-
-		/// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
-		public virtual IToken MatchWildcard()
-		{
-			IToken t = GetCurrentToken();
-			if (t.Type > 0)
-			{
-				_errHandler.EndErrorCondition(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 RuleContext objects during the parse and hook them up
-		/// using the children list so that it forms a parse tree.
-		/// </summary>
-		/// <remarks>
-		/// Track the RuleContext objects during the parse and hook them up
-		/// using the children list so that it forms a parse tree.
-		/// The RuleContext returned from the start rule represents the root
-		/// of the parse tree.
-		/// To built parse trees, all we have to do is put a hook in setState()
-		/// and enterRule(). In setState(), we add tokens to the current context
-		/// as children. By the time we get to enterRule(), we are already
-		/// in an invoked rule so we add this context as a child of the parent
-		/// (invoking) context. Simple and effective.
-		/// 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.
-		/// When we build parse trees, we are adding all of these contexts to
-		/// somebody's children list. Contexts are then not candidates
-		/// for garbage collection.
-		/// </remarks>
-		public virtual void SetBuildParseTree(bool buildParseTrees)
-		{
-			this._buildParseTrees = buildParseTrees;
-		}
-
-		public virtual bool GetBuildParseTree()
-		{
-			return _buildParseTrees;
-		}
-
-		/// <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
-		/// <code>false</code>
-		/// by default for a newly constructed parser.
-		/// </remarks>
-		/// <param name="trimParseTrees">
-		/// 
-		/// <code>true</code>
-		/// to trim the capacity of the
-		/// <see cref="ParserRuleContext.children">ParserRuleContext.children</see>
-		/// list to its size after a rule is parsed.
-		/// </param>
-		public virtual void SetTrimParseTree(bool trimParseTrees)
-		{
-			if (trimParseTrees)
-			{
-				if (GetTrimParseTree())
-				{
-					return;
-				}
-				AddParseListener(Parser.TrimToSizeListener.Instance);
-			}
-			else
-			{
-				RemoveParseListener(Parser.TrimToSizeListener.Instance);
-			}
-		}
-
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// if the
-		/// <see cref="ParserRuleContext.children">ParserRuleContext.children</see>
-		/// list is trimmed
-		/// using the default
-		/// <see cref="TrimToSizeListener">TrimToSizeListener</see>
-		/// during the parse process.
-		/// </returns>
-		public virtual bool GetTrimParseTree()
-		{
-			if (_parseListeners == null)
-			{
-				return false;
-			}
-			return _parseListeners.Contains(Parser.TrimToSizeListener.Instance);
-		}
-
-		//	public void setTraceATNStates(boolean traceATNStates) {
-		//		this.traceATNStates = traceATNStates;
-		//	}
-		//
-		//	public boolean getTraceATNStates() {
-		//		return traceATNStates;
-		//	}
-		public virtual IList<IParseTreeListener> GetParseListeners()
-		{
-			return _parseListeners;
-		}
-
-		/// <summary>
-		/// Provide a listener that gets notified about token matches,
-		/// and rule entry/exit events DURING the parse.
-		/// </summary>
-		/// <remarks>
-		/// Provide a listener that gets notified about token matches,
-		/// and rule entry/exit events DURING the parse. It's a little bit
-		/// weird for left recursive rule entry events but it's
-		/// deterministic.
-		/// THIS IS ONLY FOR ADVANCED USERS. Please give your
-		/// ParseTreeListener to a ParseTreeWalker instead of giving it to
-		/// the parser!!!!
-		/// </remarks>
-		public virtual void AddParseListener(IParseTreeListener listener)
-		{
-			if (listener == null)
-			{
-				return;
-			}
-			if (_parseListeners == null)
-			{
-				_parseListeners = new List<IParseTreeListener>();
-			}
-			this._parseListeners.AddItem(listener);
-		}
-
-		public virtual void RemoveParseListener(IParseTreeListener l)
-		{
-			if (l == null)
-			{
-				return;
-			}
-			if (_parseListeners != null)
-			{
-				_parseListeners.Remove(l);
-				if (_parseListeners.IsEmpty())
-				{
-					_parseListeners = null;
-				}
-			}
-		}
-
-		public virtual void RemoveParseListeners()
-		{
-			_parseListeners = null;
-		}
-
-		/// <summary>
-		/// Notify any parse listeners (implemented as ParseTreeListener's)
-		/// of an enter rule event.
-		/// </summary>
-		/// <remarks>
-		/// Notify any parse listeners (implemented as ParseTreeListener's)
-		/// of an enter rule event. This is not involved with
-		/// parse tree walking in any way; it's just reusing the
-		/// ParseTreeListener interface. This is not for the average user.
-		/// </remarks>
-		public virtual void TriggerEnterRuleEvent()
-		{
-			foreach (IParseTreeListener l in _parseListeners)
-			{
-				l.EnterEveryRule(_ctx);
-				_ctx.EnterRule(l);
-			}
-		}
-
-		/// <summary>
-		/// Notify any parse listeners (implemented as ParseTreeListener's)
-		/// of an exit rule event.
-		/// </summary>
-		/// <remarks>
-		/// Notify any parse listeners (implemented as ParseTreeListener's)
-		/// of an exit rule event. This is not involved with
-		/// parse tree walking in any way; it's just reusing the
-		/// ParseTreeListener interface. This is not for the average user.
-		/// </remarks>
-		public virtual void TriggerExitRuleEvent()
-		{
-			// reverse order walk of listeners
-			for (int i = _parseListeners.Count - 1; i >= 0; i--)
-			{
-				IParseTreeListener l = _parseListeners[i];
-				_ctx.ExitRule(l);
-				l.ExitEveryRule(_ctx);
-			}
-		}
-
-		/// <summary>Get number of recognition errors (lexer, parser, tree parser).</summary>
-		/// <remarks>
-		/// Get number of recognition errors (lexer, parser, tree parser).  Each
-		/// recognizer tracks its own number.  So parser and lexer each have
-		/// separate count.  Does not count the spurious errors found between
-		/// an error and next valid token match
-		/// See also reportError()
-		/// </remarks>
-		public virtual int GetNumberOfSyntaxErrors()
-		{
-			return _syntaxErrors;
-		}
-
-		public virtual IAntlrErrorStrategy GetErrorHandler()
-		{
-			return _errHandler;
-		}
-
-		public virtual void SetErrorHandler(IAntlrErrorStrategy handler)
-		{
-			this._errHandler = handler;
-		}
-
-		public override IIntStream GetInputStream()
-		{
-			return _input;
-		}
-
-		/// <summary>Set the token stream and reset the parser</summary>
-		public virtual void SetInputStream(ITokenStream input)
-		{
-			this._input = null;
-			Reset();
-			this._input = input;
-		}
-
-		/// <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 GetCurrentToken()
-		{
-			return _input.Lt(1);
-		}
-
-		public virtual void NotifyErrorListeners(string msg)
-		{
-			NotifyErrorListeners(GetCurrentToken(), msg, null);
-		}
-
-		public virtual void NotifyErrorListeners(IToken offendingToken, string msg, RecognitionException
-			 e)
-		{
-			int line = -1;
-			int charPositionInLine = -1;
-			if (offendingToken != null)
-			{
-				line = offendingToken.Line;
-				charPositionInLine = offendingToken.Column;
-			}
-			IAntlrErrorListener<IToken> listener = ((IParserErrorListener)GetErrorListenerDispatch
-				());
-			listener.SyntaxError(this, offendingToken, line, charPositionInLine, msg, e);
-		}
-
-		/// <summary>Consume the current symbol and return it.</summary>
-		/// <remarks>
-		/// Consume the current symbol and return it. E.g., given the following
-		/// input with A being the current lookahead symbol:
-		/// A B
-		/// ^
-		/// this function moves the cursor to B and returns A.
-		/// If the parser is creating parse trees, the current symbol
-		/// would also be added as a child to the current context (node).
-		/// Trigger listener events if there's a listener.
-		/// </remarks>
-		public virtual IToken Consume()
-		{
-			IToken o = GetCurrentToken();
-			if (o.Type != Eof)
-			{
-				((ITokenStream)GetInputStream()).Consume();
-			}
-			bool hasListener = _parseListeners != null && !_parseListeners.IsEmpty();
-			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.
-		/// This occurs after the new context has been pushed. Access field
-		/// _ctx get the current context.
-		/// This is flexible because users do not have to regenerate parsers
-		/// to get trace facilities.
-		/// </remarks>
-		public virtual void EnterRule(ParserRuleContext localctx, int state, int ruleIndex
-			)
-		{
-			SetState(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)
-		{
-			SetState(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();
-			}
-			SetState(_ctx.invokingState);
-			_ctx = (ParserRuleContext)_ctx.parent;
-		}
-
-		public virtual void EnterOuterAlt(ParserRuleContext localctx, int 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;
-			_ctx.altNum = altNum;
-		}
-
-		public virtual void EnterRecursionRule(ParserRuleContext localctx, int ruleIndex, 
-			int precedence)
-		{
-			_precedenceStack.Push(precedence);
-			_ctx = localctx;
-			_ctx.start = _input.Lt(1);
-			if (_parseListeners != null)
-			{
-				TriggerEnterRuleEvent();
-			}
-		}
-
-		// simulates rule entry for left-recursive rules
-		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.Pop();
-			_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.AddChild(retctx);
-			}
-		}
-
-		// add return ctx into invoking rule's tree
-		public virtual ParserRuleContext GetInvokingContext(int ruleIndex)
-		{
-			ParserRuleContext p = _ctx;
-			while (p != null)
-			{
-				if (p.GetRuleIndex() == ruleIndex)
-				{
-					return p;
-				}
-				p = (ParserRuleContext)p.parent;
-			}
-			return null;
-		}
-
-		public virtual ParserRuleContext GetContext()
-		{
-			return _ctx;
-		}
-
-		public override bool Precpred(RuleContext localctx, int precedence)
-		{
-			return precedence >= _precedenceStack.Peek();
-		}
-
-		public override IAntlrErrorListener<IToken> GetErrorListenerDispatch()
-		{
-			return new ProxyParserErrorListener(GetErrorListeners());
-		}
-
-		public virtual bool InContext(string context)
-		{
-			// TODO: useful in parser?
-			return false;
-		}
-
-		public virtual bool IsExpectedToken(int symbol)
-		{
-			//   		return getInterpreter().atn.nextTokens(_ctx);
-			ATN atn = GetInterpreter().atn;
-			ParserRuleContext ctx = _ctx;
-			ATNState s = atn.states[GetState()];
-			IntervalSet following = atn.NextTokens(s);
-			if (following.Contains(symbol))
-			{
-				return true;
-			}
-			//        System.out.println("following "+s+"="+following);
-			if (!following.Contains(IToken.Epsilon))
-			{
-				return false;
-			}
-			while (ctx != null && ctx.invokingState >= 0 && following.Contains(IToken.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(IToken.Epsilon) && symbol == IToken.Eof)
-			{
-				return true;
-			}
-			return false;
-		}
-
-		/// <summary>
-		/// Compute the set of valid tokens reachable from the current
-		/// position in the parse.
-		/// </summary>
-		/// <remarks>
-		/// Compute the set of valid tokens reachable from the current
-		/// position in the parse.
-		/// </remarks>
-		public virtual IntervalSet GetExpectedTokens()
-		{
-			ATN atn = GetInterpreter().atn;
-			ParserRuleContext ctx = _ctx;
-			ATNState s = atn.states[GetState()];
-			IntervalSet following = atn.NextTokens(s);
-			//        System.out.println("following "+s+"="+following);
-			if (!following.Contains(IToken.Epsilon))
-			{
-				return following;
-			}
-			IntervalSet expected = new IntervalSet();
-			expected.AddAll(following);
-			expected.Remove(IToken.Epsilon);
-			while (ctx != null && ctx.invokingState >= 0 && following.Contains(IToken.Epsilon
-				))
-			{
-				ATNState invokingState = atn.states[ctx.invokingState];
-				RuleTransition rt = (RuleTransition)invokingState.Transition(0);
-				following = atn.NextTokens(rt.followState);
-				expected.AddAll(following);
-				expected.Remove(IToken.Epsilon);
-				ctx = (ParserRuleContext)ctx.parent;
-			}
-			if (following.Contains(IToken.Epsilon))
-			{
-				expected.Add(IToken.Eof);
-			}
-			return expected;
-		}
-
-		public virtual IntervalSet GetExpectedTokensWithinCurrentRule()
-		{
-			ATN atn = GetInterpreter().atn;
-			ATNState s = atn.states[GetState()];
-			return atn.NextTokens(s);
-		}
-
-		//	/** Compute the set of valid tokens reachable from the current
-		//	 *  position in the parse.
-		//	 */
-		//	public IntervalSet nextTokens(@NotNull RuleContext ctx) {
-		//		ATN atn = getInterpreter().atn;
-		//		ATNState s = atn.states.get(ctx.s);
-		//		if ( s == null ) return null;
-		//		return atn.nextTokens(s, ctx);
-		//	}
-		public virtual ParserRuleContext GetRuleContext()
-		{
-			return _ctx;
-		}
-
-		/// <summary>
-		/// Return List<String> of the rule names in your parser instance
-		/// leading up to a call to the current rule.
-		/// </summary>
-		/// <remarks>
-		/// Return List<String> 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 IList<string> GetRuleInvocationStack(RuleContext p)
-		{
-			string[] ruleNames = GetRuleNames();
-			IList<string> stack = new List<string>();
-			while (p != null)
-			{
-				// compute what follows who invoked us
-				int ruleIndex = p.GetRuleIndex();
-				if (ruleIndex < 0)
-				{
-					stack.AddItem("n/a");
-				}
-				else
-				{
-					stack.AddItem(ruleNames[ruleIndex]);
-				}
-				p = p.parent;
-			}
-			return stack;
-		}
-
-		/// <summary>For debugging and other purposes</summary>
-		public virtual IList<string> GetDFAStrings()
-		{
-			IList<string> s = new List<string>();
-			for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
-			{
-				DFA dfa = _interp.atn.decisionToDFA[d];
-				s.AddItem(dfa.ToString(GetTokenNames(), GetRuleNames()));
-			}
-			return s;
-		}
-
-		/// <summary>For debugging and other purposes</summary>
-		public virtual void DumpDFA()
-		{
-			bool seenOne = false;
-			for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
-			{
-				DFA dfa = _interp.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(GetTokenNames(), GetRuleNames()));
-					seenOne = true;
-				}
-			}
-		}
-
-		public virtual string GetSourceName()
-		{
-			return _input.SourceName;
-		}
-
-		/// <summary>A convenience method for use most often with template rewrites.</summary>
-		/// <remarks>
-		/// A convenience method for use most often with template rewrites.
-		/// Convert a List<Token> to List<String>
-		/// </remarks>
-		public virtual IList<string> ToStrings<_T0>(IList<_T0> tokens) where _T0:IToken
-		{
-			if (tokens == null)
-			{
-				return null;
-			}
-			IList<string> strings = new List<string>(tokens.Count);
-			for (int i = 0; i < tokens.Count; i++)
-			{
-				strings.AddItem(tokens[i].Text);
-			}
-			return strings;
-		}
-
-		/// <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 void SetTrace(bool trace)
-		{
-			if (!trace)
-			{
-				RemoveParseListener(_tracer);
-				_tracer = null;
-			}
-			else
-			{
-				if (_tracer != null)
-				{
-					RemoveParseListener(_tracer);
-				}
-				else
-				{
-					_tracer = new Parser.TraceListener(this);
-				}
-				AddParseListener(_tracer);
-			}
-		}
-	}
+    /// <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>
+    {
+        public class TraceListener : IParseTreeListener
+        {
+            public virtual void EnterEveryRule(ParserRuleContext ctx)
+            {
+                System.Console.Out.WriteLine("enter   " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
+                    ()] + ", LT(1)=" + this._enclosing._input.Lt(1).Text);
+            }
+
+            public virtual void ExitEveryRule(ParserRuleContext ctx)
+            {
+                System.Console.Out.WriteLine("exit    " + this._enclosing.GetRuleNames()[ctx.GetRuleIndex
+                    ()] + ", 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.GetRuleNames
+                    ()[parent.GetRuleIndex()] + " alt=" + parent.altNum);
+            }
+
+            internal TraceListener(Parser _enclosing)
+            {
+                this._enclosing = _enclosing;
+            }
+
+            private readonly Parser _enclosing;
+        }
+
+        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 ArrayList)
+                {
+                    ((List<object>)ctx.children).TrimToSize();
+                }
+            }
+        }
+
+        protected internal IAntlrErrorStrategy _errHandler = new DefaultErrorStrategy();
+
+        protected internal ITokenStream _input;
+
+        protected internal readonly IntegerStack _precedenceStack;
+
+        /// <summary>The RuleContext object for the currently executing rule.</summary>
+        /// <remarks>
+        /// The RuleContext object for the currently executing rule. This
+        /// must be non-null during parsing, but is initially null.
+        /// When somebody calls the start rule, this gets set to the
+        /// root context.
+        /// </remarks>
+        protected internal ParserRuleContext _ctx;
+
+        protected internal bool _buildParseTrees = true;
+
+        protected internal Parser.TraceListener _tracer;
+
+        /// <summary>
+        /// If the listener is non-null, trigger enter and exit rule events
+        /// *during* the parse.
+        /// </summary>
+        /// <remarks>
+        /// If the listener is non-null, trigger enter and exit rule events
+        /// *during* the parse. This is typically done only when not building
+        /// parse trees for later visiting. We either trigger events during
+        /// the parse or during tree walks later. Both could be done.
+        /// Not intended for average user!!!  Most people should use
+        /// ParseTreeListener with ParseTreeWalker.
+        /// </remarks>
+        /// <seealso cref="Antlr4.Runtime.Tree.ParseTreeWalker">Antlr4.Runtime.Tree.ParseTreeWalker
+        ///     </seealso>
+        protected internal IList<IParseTreeListener> _parseListeners;
+
+        /// <summary>Did the recognizer encounter a syntax error?  Track how many.</summary>
+        /// <remarks>Did the recognizer encounter a syntax error?  Track how many.</remarks>
+        protected internal int _syntaxErrors = 0;
+
+        public Parser(ITokenStream input)
+        {
+            {
+                _precedenceStack = new IntegerStack();
+                _precedenceStack.Push(0);
+            }
+            SetInputStream(input);
+        }
+
+        /// <summary>reset the parser's state</summary>
+        public virtual void Reset()
+        {
+            if (((ITokenStream)GetInputStream()) != null)
+            {
+                ((ITokenStream)GetInputStream()).Seek(0);
+            }
+            _errHandler.EndErrorCondition(this);
+            _ctx = null;
+            _syntaxErrors = 0;
+            _tracer = null;
+            _precedenceStack.Clear();
+            _precedenceStack.Push(0);
+            ATNSimulator interpreter = GetInterpreter();
+            if (interpreter != null)
+            {
+                interpreter.Reset();
+            }
+        }
+
+        /// <summary>Match current input symbol against ttype.</summary>
+        /// <remarks>
+        /// Match current input symbol against ttype.  Attempt
+        /// single token insertion or deletion error recovery.  If
+        /// that fails, throw MismatchedTokenException.
+        /// </remarks>
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        public virtual IToken Match(int ttype)
+        {
+            IToken t = GetCurrentToken();
+            if (t.Type == ttype)
+            {
+                _errHandler.EndErrorCondition(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;
+        }
+
+        /// <exception cref="Antlr4.Runtime.RecognitionException"></exception>
+        public virtual IToken MatchWildcard()
+        {
+            IToken t = GetCurrentToken();
+            if (t.Type > 0)
+            {
+                _errHandler.EndErrorCondition(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 RuleContext objects during the parse and hook them up
+        /// using the children list so that it forms a parse tree.
+        /// </summary>
+        /// <remarks>
+        /// Track the RuleContext objects during the parse and hook them up
+        /// using the children list so that it forms a parse tree.
+        /// The RuleContext returned from the start rule represents the root
+        /// of the parse tree.
+        /// To built parse trees, all we have to do is put a hook in setState()
+        /// and enterRule(). In setState(), we add tokens to the current context
+        /// as children. By the time we get to enterRule(), we are already
+        /// in an invoked rule so we add this context as a child of the parent
+        /// (invoking) context. Simple and effective.
+        /// 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.
+        /// When we build parse trees, we are adding all of these contexts to
+        /// somebody's children list. Contexts are then not candidates
+        /// for garbage collection.
+        /// </remarks>
+        public virtual void SetBuildParseTree(bool buildParseTrees)
+        {
+            this._buildParseTrees = buildParseTrees;
+        }
+
+        public virtual bool GetBuildParseTree()
+        {
+            return _buildParseTrees;
+        }
+
+        /// <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
+        /// <code>false</code>
+        /// by default for a newly constructed parser.
+        /// </remarks>
+        /// <param name="trimParseTrees">
+        /// 
+        /// <code>true</code>
+        /// to trim the capacity of the
+        /// <see cref="ParserRuleContext.children">ParserRuleContext.children</see>
+        /// list to its size after a rule is parsed.
+        /// </param>
+        public virtual void SetTrimParseTree(bool trimParseTrees)
+        {
+            if (trimParseTrees)
+            {
+                if (GetTrimParseTree())
+                {
+                    return;
+                }
+                AddParseListener(Parser.TrimToSizeListener.Instance);
+            }
+            else
+            {
+                RemoveParseListener(Parser.TrimToSizeListener.Instance);
+            }
+        }
+
+        /// <returns>
+        /// 
+        /// <code>true</code>
+        /// if the
+        /// <see cref="ParserRuleContext.children">ParserRuleContext.children</see>
+        /// list is trimmed
+        /// using the default
+        /// <see cref="TrimToSizeListener">TrimToSizeListener</see>
+        /// during the parse process.
+        /// </returns>
+        public virtual bool GetTrimParseTree()
+        {
+            if (_parseListeners == null)
+            {
+                return false;
+            }
+            return _parseListeners.Contains(Parser.TrimToSizeListener.Instance);
+        }
+
+        //	public void setTraceATNStates(boolean traceATNStates) {
+        //		this.traceATNStates = traceATNStates;
+        //	}
+        //
+        //	public boolean getTraceATNStates() {
+        //		return traceATNStates;
+        //	}
+        public virtual IList<IParseTreeListener> GetParseListeners()
+        {
+            return _parseListeners;
+        }
+
+        /// <summary>
+        /// Provide a listener that gets notified about token matches,
+        /// and rule entry/exit events DURING the parse.
+        /// </summary>
+        /// <remarks>
+        /// Provide a listener that gets notified about token matches,
+        /// and rule entry/exit events DURING the parse. It's a little bit
+        /// weird for left recursive rule entry events but it's
+        /// deterministic.
+        /// THIS IS ONLY FOR ADVANCED USERS. Please give your
+        /// ParseTreeListener to a ParseTreeWalker instead of giving it to
+        /// the parser!!!!
+        /// </remarks>
+        public virtual void AddParseListener(IParseTreeListener listener)
+        {
+            if (listener == null)
+            {
+                return;
+            }
+            if (_parseListeners == null)
+            {
+                _parseListeners = new List<IParseTreeListener>();
+            }
+            this._parseListeners.AddItem(listener);
+        }
+
+        public virtual void RemoveParseListener(IParseTreeListener l)
+        {
+            if (l == null)
+            {
+                return;
+            }
+            if (_parseListeners != null)
+            {
+                _parseListeners.Remove(l);
+                if (_parseListeners.IsEmpty())
+                {
+                    _parseListeners = null;
+                }
+            }
+        }
+
+        public virtual void RemoveParseListeners()
+        {
+            _parseListeners = null;
+        }
+
+        /// <summary>
+        /// Notify any parse listeners (implemented as ParseTreeListener's)
+        /// of an enter rule event.
+        /// </summary>
+        /// <remarks>
+        /// Notify any parse listeners (implemented as ParseTreeListener's)
+        /// of an enter rule event. This is not involved with
+        /// parse tree walking in any way; it's just reusing the
+        /// ParseTreeListener interface. This is not for the average user.
+        /// </remarks>
+        public virtual void TriggerEnterRuleEvent()
+        {
+            foreach (IParseTreeListener l in _parseListeners)
+            {
+                l.EnterEveryRule(_ctx);
+                _ctx.EnterRule(l);
+            }
+        }
+
+        /// <summary>
+        /// Notify any parse listeners (implemented as ParseTreeListener's)
+        /// of an exit rule event.
+        /// </summary>
+        /// <remarks>
+        /// Notify any parse listeners (implemented as ParseTreeListener's)
+        /// of an exit rule event. This is not involved with
+        /// parse tree walking in any way; it's just reusing the
+        /// ParseTreeListener interface. This is not for the average user.
+        /// </remarks>
+        public virtual void TriggerExitRuleEvent()
+        {
+            // reverse order walk of listeners
+            for (int i = _parseListeners.Count - 1; i >= 0; i--)
+            {
+                IParseTreeListener l = _parseListeners[i];
+                _ctx.ExitRule(l);
+                l.ExitEveryRule(_ctx);
+            }
+        }
+
+        /// <summary>Get number of recognition errors (lexer, parser, tree parser).</summary>
+        /// <remarks>
+        /// Get number of recognition errors (lexer, parser, tree parser).  Each
+        /// recognizer tracks its own number.  So parser and lexer each have
+        /// separate count.  Does not count the spurious errors found between
+        /// an error and next valid token match
+        /// See also reportError()
+        /// </remarks>
+        public virtual int GetNumberOfSyntaxErrors()
+        {
+            return _syntaxErrors;
+        }
+
+        public virtual IAntlrErrorStrategy GetErrorHandler()
+        {
+            return _errHandler;
+        }
+
+        public virtual void SetErrorHandler(IAntlrErrorStrategy handler)
+        {
+            this._errHandler = handler;
+        }
+
+        public override IIntStream GetInputStream()
+        {
+            return _input;
+        }
+
+        /// <summary>Set the token stream and reset the parser</summary>
+        public virtual void SetInputStream(ITokenStream input)
+        {
+            this._input = null;
+            Reset();
+            this._input = input;
+        }
+
+        /// <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 GetCurrentToken()
+        {
+            return _input.Lt(1);
+        }
+
+        public virtual void NotifyErrorListeners(string msg)
+        {
+            NotifyErrorListeners(GetCurrentToken(), msg, null);
+        }
+
+        public virtual void NotifyErrorListeners(IToken offendingToken, string msg, RecognitionException
+             e)
+        {
+            int line = -1;
+            int charPositionInLine = -1;
+            if (offendingToken != null)
+            {
+                line = offendingToken.Line;
+                charPositionInLine = offendingToken.Column;
+            }
+            IAntlrErrorListener<IToken> listener = ((IParserErrorListener)GetErrorListenerDispatch
+                ());
+            listener.SyntaxError(this, offendingToken, line, charPositionInLine, msg, e);
+        }
+
+        /// <summary>Consume the current symbol and return it.</summary>
+        /// <remarks>
+        /// Consume the current symbol and return it. E.g., given the following
+        /// input with A being the current lookahead symbol:
+        /// A B
+        /// ^
+        /// this function moves the cursor to B and returns A.
+        /// If the parser is creating parse trees, the current symbol
+        /// would also be added as a child to the current context (node).
+        /// Trigger listener events if there's a listener.
+        /// </remarks>
+        public virtual IToken Consume()
+        {
+            IToken o = GetCurrentToken();
+            if (o.Type != Eof)
+            {
+                ((ITokenStream)GetInputStream()).Consume();
+            }
+            bool hasListener = _parseListeners != null && !_parseListeners.IsEmpty();
+            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.
+        /// This occurs after the new context has been pushed. Access field
+        /// _ctx get the current context.
+        /// This is flexible because users do not have to regenerate parsers
+        /// to get trace facilities.
+        /// </remarks>
+        public virtual void EnterRule(ParserRuleContext localctx, int state, int ruleIndex
+            )
+        {
+            SetState(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)
+        {
+            SetState(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();
+            }
+            SetState(_ctx.invokingState);
+            _ctx = (ParserRuleContext)_ctx.parent;
+        }
+
+        public virtual void EnterOuterAlt(ParserRuleContext localctx, int 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;
+            _ctx.altNum = altNum;
+        }
+
+        public virtual void EnterRecursionRule(ParserRuleContext localctx, int ruleIndex, 
+            int precedence)
+        {
+            _precedenceStack.Push(precedence);
+            _ctx = localctx;
+            _ctx.start = _input.Lt(1);
+            if (_parseListeners != null)
+            {
+                TriggerEnterRuleEvent();
+            }
+        }
+
+        // simulates rule entry for left-recursive rules
+        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.Pop();
+            _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.AddChild(retctx);
+            }
+        }
+
+        // add return ctx into invoking rule's tree
+        public virtual ParserRuleContext GetInvokingContext(int ruleIndex)
+        {
+            ParserRuleContext p = _ctx;
+            while (p != null)
+            {
+                if (p.GetRuleIndex() == ruleIndex)
+                {
+                    return p;
+                }
+                p = (ParserRuleContext)p.parent;
+            }
+            return null;
+        }
+
+        public virtual ParserRuleContext GetContext()
+        {
+            return _ctx;
+        }
+
+        public override bool Precpred(RuleContext localctx, int precedence)
+        {
+            return precedence >= _precedenceStack.Peek();
+        }
+
+        public override IAntlrErrorListener<IToken> GetErrorListenerDispatch()
+        {
+            return new ProxyParserErrorListener(GetErrorListeners());
+        }
+
+        public virtual bool InContext(string context)
+        {
+            // TODO: useful in parser?
+            return false;
+        }
+
+        public virtual bool IsExpectedToken(int symbol)
+        {
+            //   		return getInterpreter().atn.nextTokens(_ctx);
+            ATN atn = GetInterpreter().atn;
+            ParserRuleContext ctx = _ctx;
+            ATNState s = atn.states[GetState()];
+            IntervalSet following = atn.NextTokens(s);
+            if (following.Contains(symbol))
+            {
+                return true;
+            }
+            //        System.out.println("following "+s+"="+following);
+            if (!following.Contains(IToken.Epsilon))
+            {
+                return false;
+            }
+            while (ctx != null && ctx.invokingState >= 0 && following.Contains(IToken.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(IToken.Epsilon) && symbol == IToken.Eof)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Compute the set of valid tokens reachable from the current
+        /// position in the parse.
+        /// </summary>
+        /// <remarks>
+        /// Compute the set of valid tokens reachable from the current
+        /// position in the parse.
+        /// </remarks>
+        public virtual IntervalSet GetExpectedTokens()
+        {
+            ATN atn = GetInterpreter().atn;
+            ParserRuleContext ctx = _ctx;
+            ATNState s = atn.states[GetState()];
+            IntervalSet following = atn.NextTokens(s);
+            //        System.out.println("following "+s+"="+following);
+            if (!following.Contains(IToken.Epsilon))
+            {
+                return following;
+            }
+            IntervalSet expected = new IntervalSet();
+            expected.AddAll(following);
+            expected.Remove(IToken.Epsilon);
+            while (ctx != null && ctx.invokingState >= 0 && following.Contains(IToken.Epsilon
+                ))
+            {
+                ATNState invokingState = atn.states[ctx.invokingState];
+                RuleTransition rt = (RuleTransition)invokingState.Transition(0);
+                following = atn.NextTokens(rt.followState);
+                expected.AddAll(following);
+                expected.Remove(IToken.Epsilon);
+                ctx = (ParserRuleContext)ctx.parent;
+            }
+            if (following.Contains(IToken.Epsilon))
+            {
+                expected.Add(IToken.Eof);
+            }
+            return expected;
+        }
+
+        public virtual IntervalSet GetExpectedTokensWithinCurrentRule()
+        {
+            ATN atn = GetInterpreter().atn;
+            ATNState s = atn.states[GetState()];
+            return atn.NextTokens(s);
+        }
+
+        //	/** Compute the set of valid tokens reachable from the current
+        //	 *  position in the parse.
+        //	 */
+        //	public IntervalSet nextTokens(@NotNull RuleContext ctx) {
+        //		ATN atn = getInterpreter().atn;
+        //		ATNState s = atn.states.get(ctx.s);
+        //		if ( s == null ) return null;
+        //		return atn.nextTokens(s, ctx);
+        //	}
+        public virtual ParserRuleContext GetRuleContext()
+        {
+            return _ctx;
+        }
+
+        /// <summary>
+        /// Return List<String> of the rule names in your parser instance
+        /// leading up to a call to the current rule.
+        /// </summary>
+        /// <remarks>
+        /// Return List<String> 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 IList<string> GetRuleInvocationStack(RuleContext p)
+        {
+            string[] ruleNames = GetRuleNames();
+            IList<string> stack = new List<string>();
+            while (p != null)
+            {
+                // compute what follows who invoked us
+                int ruleIndex = p.GetRuleIndex();
+                if (ruleIndex < 0)
+                {
+                    stack.AddItem("n/a");
+                }
+                else
+                {
+                    stack.AddItem(ruleNames[ruleIndex]);
+                }
+                p = p.parent;
+            }
+            return stack;
+        }
+
+        /// <summary>For debugging and other purposes</summary>
+        public virtual IList<string> GetDFAStrings()
+        {
+            IList<string> s = new List<string>();
+            for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
+            {
+                DFA dfa = _interp.atn.decisionToDFA[d];
+                s.AddItem(dfa.ToString(GetTokenNames(), GetRuleNames()));
+            }
+            return s;
+        }
+
+        /// <summary>For debugging and other purposes</summary>
+        public virtual void DumpDFA()
+        {
+            bool seenOne = false;
+            for (int d = 0; d < _interp.atn.decisionToDFA.Length; d++)
+            {
+                DFA dfa = _interp.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(GetTokenNames(), GetRuleNames()));
+                    seenOne = true;
+                }
+            }
+        }
+
+        public virtual string GetSourceName()
+        {
+            return _input.SourceName;
+        }
+
+        /// <summary>A convenience method for use most often with template rewrites.</summary>
+        /// <remarks>
+        /// A convenience method for use most often with template rewrites.
+        /// Convert a List<Token> to List<String>
+        /// </remarks>
+        public virtual IList<string> ToStrings<_T0>(IList<_T0> tokens) where _T0:IToken
+        {
+            if (tokens == null)
+            {
+                return null;
+            }
+            IList<string> strings = new List<string>(tokens.Count);
+            for (int i = 0; i < tokens.Count; i++)
+            {
+                strings.AddItem(tokens[i].Text);
+            }
+            return strings;
+        }
+
+        /// <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 void SetTrace(bool trace)
+        {
+            if (!trace)
+            {
+                RemoveParseListener(_tracer);
+                _tracer = null;
+            }
+            else
+            {
+                if (_tracer != null)
+                {
+                    RemoveParseListener(_tracer);
+                }
+                else
+                {
+                    _tracer = new Parser.TraceListener(this);
+                }
+                AddParseListener(_tracer);
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ParserRuleContext.cs b/Antlr4.Runtime/ParserRuleContext.cs
index 14e660ec8..612fed87a 100644
--- a/Antlr4.Runtime/ParserRuleContext.cs
+++ b/Antlr4.Runtime/ParserRuleContext.cs
@@ -36,356 +36,356 @@ using Sharpen;
 
 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>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>
+        /// 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>
-		public 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>
+        public 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>
-		public IToken stop;
+        /// <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>
+        public IToken stop;
 
-		/// <summary>Set during parsing to identify which alt of rule parser is in.</summary>
-		/// <remarks>Set during parsing to identify which alt of rule parser is in.</remarks>
-		public int altNum;
+        /// <summary>Set during parsing to identify which alt of rule parser is in.</summary>
+        /// <remarks>Set during parsing to identify which alt of rule parser is in.</remarks>
+        public int altNum;
 
-		/// <summary>The exception which forced this rule to return.</summary>
-		/// <remarks>
-		/// The exception which forced this rule to return. If the rule successfully
-		/// completed, this is
-		/// <code>null</code>
-		/// .
-		/// </remarks>
-		public RecognitionException exception;
+        /// <summary>The exception which forced this rule to return.</summary>
+        /// <remarks>
+        /// The exception which forced this rule to return. If the rule successfully
+        /// completed, this is
+        /// <code>null</code>
+        /// .
+        /// </remarks>
+        public RecognitionException exception;
 
-		public ParserRuleContext()
-		{
-		}
+        public ParserRuleContext()
+        {
+        }
 
-		//	public List<Integer> states;
-		public static Antlr4.Runtime.ParserRuleContext EmptyContext()
-		{
-			return Empty;
-		}
+        //	public List<Integer> states;
+        public static Antlr4.Runtime.ParserRuleContext EmptyContext()
+        {
+            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;
-		}
+        /// <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)
-		{
-		}
+        public ParserRuleContext(Antlr4.Runtime.ParserRuleContext parent, int invokingStateNumber
+            ) : base(parent, invokingStateNumber)
+        {
+        }
 
-		// Double dispatch methods for listeners
-		public virtual void EnterRule(IParseTreeListener listener)
-		{
-		}
+        // Double dispatch methods for listeners
+        public virtual void EnterRule(IParseTreeListener listener)
+        {
+        }
 
-		public virtual void ExitRule(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.AddItem(t);
-		}
+        /// <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.AddItem(t);
+        }
 
-		public virtual void AddChild(RuleContext ruleInvocation)
-		{
-			if (children == null)
-			{
-				children = new List<IParseTree>();
-			}
-			children.AddItem(ruleInvocation);
-		}
+        public virtual void AddChild(RuleContext ruleInvocation)
+        {
+            if (children == null)
+            {
+                children = new List<IParseTree>();
+            }
+            children.AddItem(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.Remove(children.Count - 1);
-			}
-		}
+        /// <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.Remove(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 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 virtual IErrorNode AddErrorNode(IToken badToken)
+        {
+            ErrorNodeImpl t = new ErrorNodeImpl(badToken);
+            AddChild(t);
+            t.parent = this;
+            return t;
+        }
 
-		public override RuleContext Parent
-		{
-			get
-			{
-				return (Antlr4.Runtime.ParserRuleContext)base.Parent;
-			}
-		}
+        public override RuleContext Parent
+        {
+            get
+            {
+                return (Antlr4.Runtime.ParserRuleContext)base.Parent;
+            }
+        }
 
-		public override IParseTree GetChild(int i)
-		{
-			return children != null && i >= 0 && i < children.Count ? children[i] : null;
-		}
+        public override IParseTree GetChild(int i)
+        {
+            return children != null && i >= 0 && i < children.Count ? children[i] : null;
+        }
 
-		public virtual T GetChild<T, _T1>(Type<_T1> ctxType, int i) where T:IParseTree where 
-			_T1:T
-		{
-			if (children == null || i < 0 || i >= children.Count)
-			{
-				return null;
-			}
-			int j = -1;
-			// what element have we found with ctxType?
-			foreach (IParseTree o in children)
-			{
-				if (ctxType.IsInstanceOfType(o))
-				{
-					j++;
-					if (j == i)
-					{
-						return ctxType.Cast(o);
-					}
-				}
-			}
-			return null;
-		}
+        public virtual T GetChild<T, _T1>(Type<_T1> ctxType, int i) where T:IParseTree where 
+            _T1:T
+        {
+            if (children == null || i < 0 || i >= children.Count)
+            {
+                return null;
+            }
+            int j = -1;
+            // what element have we found with ctxType?
+            foreach (IParseTree o in children)
+            {
+                if (ctxType.IsInstanceOfType(o))
+                {
+                    j++;
+                    if (j == i)
+                    {
+                        return ctxType.Cast(o);
+                    }
+                }
+            }
+            return null;
+        }
 
-		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;
-		}
+        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;
+        }
 
-		public virtual IList<ITerminalNode> GetTokens(int ttype)
-		{
-			if (children == null)
-			{
-				return Sharpen.Collections.EmptyList();
-			}
-			IList<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.AddItem(tnode);
-					}
-				}
-			}
-			if (tokens == null)
-			{
-				return Sharpen.Collections.EmptyList();
-			}
-			return tokens;
-		}
+        public virtual IList<ITerminalNode> GetTokens(int ttype)
+        {
+            if (children == null)
+            {
+                return Sharpen.Collections.EmptyList();
+            }
+            IList<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.AddItem(tnode);
+                    }
+                }
+            }
+            if (tokens == null)
+            {
+                return Sharpen.Collections.EmptyList();
+            }
+            return tokens;
+        }
 
-		public virtual T GetRuleContext<T, _T1>(Type<_T1> ctxType, int i) where T:Antlr4.Runtime.ParserRuleContext
-			 where _T1:T
-		{
-			return GetChild(ctxType, i);
-		}
+        public virtual T GetRuleContext<T, _T1>(Type<_T1> ctxType, int i) where T:Antlr4.Runtime.ParserRuleContext
+             where _T1:T
+        {
+            return GetChild(ctxType, i);
+        }
 
-		public virtual IList<T> GetRuleContexts<T, _T1>(Type<_T1> ctxType) where T:Antlr4.Runtime.ParserRuleContext
-			 where _T1:T
-		{
-			if (children == null)
-			{
-				return Sharpen.Collections.EmptyList();
-			}
-			IList<T> contexts = null;
-			foreach (IParseTree o in children)
-			{
-				if (ctxType.IsInstanceOfType(o))
-				{
-					if (contexts == null)
-					{
-						contexts = new List<T>();
-					}
-					contexts.AddItem(ctxType.Cast(o));
-				}
-			}
-			if (contexts == null)
-			{
-				return Sharpen.Collections.EmptyList();
-			}
-			return contexts;
-		}
+        public virtual IList<T> GetRuleContexts<T, _T1>(Type<_T1> ctxType) where T:Antlr4.Runtime.ParserRuleContext
+             where _T1:T
+        {
+            if (children == null)
+            {
+                return Sharpen.Collections.EmptyList();
+            }
+            IList<T> contexts = null;
+            foreach (IParseTree o in children)
+            {
+                if (ctxType.IsInstanceOfType(o))
+                {
+                    if (contexts == null)
+                    {
+                        contexts = new List<T>();
+                    }
+                    contexts.AddItem(ctxType.Cast(o));
+                }
+            }
+            if (contexts == null)
+            {
+                return Sharpen.Collections.EmptyList();
+            }
+            return contexts;
+        }
 
-		public override int ChildCount
-		{
-			get
-			{
-				return children != null ? children.Count : 0;
-			}
-		}
+        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 override Interval SourceInterval
+        {
+            get
+            {
+                if (start == null || stop == null)
+                {
+                    return Interval.Invalid;
+                }
+                return Interval.Of(start.TokenIndex, stop.TokenIndex);
+            }
+        }
 
-		public virtual IToken GetStart()
-		{
-			return start;
-		}
+        public virtual IToken GetStart()
+        {
+            return start;
+        }
 
-		public virtual IToken GetStop()
-		{
-			return stop;
-		}
+        public virtual IToken GetStop()
+        {
+            return stop;
+        }
 
-		/// <summary>Used for rule context info debugging during parse-time, not so much for ATN debugging
-		/// 	</summary>
-		public virtual string ToInfoString(Parser recognizer)
-		{
-			IList<string> rules = recognizer.GetRuleInvocationStack(this);
-			Sharpen.Collections.Reverse(rules);
-			return "ParserRuleContext" + rules + "{" + "altNum=" + altNum + ", start=" + start
-				 + ", stop=" + stop + '}';
-		}
-	}
+        /// <summary>Used for rule context info debugging during parse-time, not so much for ATN debugging
+        ///     </summary>
+        public virtual string ToInfoString(Parser recognizer)
+        {
+            IList<string> rules = recognizer.GetRuleInvocationStack(this);
+            Sharpen.Collections.Reverse(rules);
+            return "ParserRuleContext" + rules + "{" + "altNum=" + altNum + ", start=" + start
+                 + ", stop=" + stop + '}';
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ProxyErrorListener`1.cs b/Antlr4.Runtime/ProxyErrorListener`1.cs
index b24e400eb..3a1b57ccd 100644
--- a/Antlr4.Runtime/ProxyErrorListener`1.cs
+++ b/Antlr4.Runtime/ProxyErrorListener`1.cs
@@ -33,31 +33,31 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <author>Sam Harwell</author>
-	public class ProxyErrorListener<Symbol> : IAntlrErrorListener<Symbol>
-	{
-		private readonly ICollection<IAntlrErrorListener<Symbol>> delegates;
+    /// <author>Sam Harwell</author>
+    public class ProxyErrorListener<Symbol> : IAntlrErrorListener<Symbol>
+    {
+        private readonly ICollection<IAntlrErrorListener<Symbol>> delegates;
 
-		public ProxyErrorListener(ICollection<IAntlrErrorListener<Symbol>> delegates)
-		{
-			this.delegates = delegates;
-		}
+        public ProxyErrorListener(ICollection<IAntlrErrorListener<Symbol>> delegates)
+        {
+            this.delegates = delegates;
+        }
 
-		protected internal virtual ICollection<IAntlrErrorListener<Symbol>> GetDelegates(
-			)
-		{
-			return delegates;
-		}
+        protected internal virtual ICollection<IAntlrErrorListener<Symbol>> GetDelegates(
+            )
+        {
+            return delegates;
+        }
 
-		public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
-			, int line, int charPositionInLine, string msg, RecognitionException e) where T:
-			Symbol
-		{
-			foreach (IAntlrErrorListener<Symbol> listener in delegates)
-			{
-				listener.SyntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, 
-					e);
-			}
-		}
-	}
+        public virtual void SyntaxError<T>(Recognizer<T, object> recognizer, T offendingSymbol
+            , int line, int charPositionInLine, string msg, RecognitionException e) where 
+            T:Symbol
+        {
+            foreach (IAntlrErrorListener<Symbol> listener in delegates)
+            {
+                listener.SyntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, 
+                    e);
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/ProxyParserErrorListener.cs b/Antlr4.Runtime/ProxyParserErrorListener.cs
index 59232baa6..ef48ed9e6 100644
--- a/Antlr4.Runtime/ProxyParserErrorListener.cs
+++ b/Antlr4.Runtime/ProxyParserErrorListener.cs
@@ -35,57 +35,57 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	/// <author>Sam Harwell</author>
-	public class ProxyParserErrorListener : ProxyErrorListener<IToken>, IParserErrorListener
-	{
-		public ProxyParserErrorListener(ICollection<IAntlrErrorListener<IToken>> delegates
-			) : base(delegates)
-		{
-		}
+    /// <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, BitSet ambigAlts, ATNConfigSet configs)
-		{
-			foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
-			{
-				if (!(listener is IParserErrorListener))
-				{
-					continue;
-				}
-				IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
-				parserErrorListener.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, ambigAlts
-					, configs);
-			}
-		}
+        public virtual void ReportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int
+             stopIndex, BitSet ambigAlts, ATNConfigSet configs)
+        {
+            foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
+            {
+                if (!(listener is IParserErrorListener))
+                {
+                    continue;
+                }
+                IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
+                parserErrorListener.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, ambigAlts
+                    , configs);
+            }
+        }
 
-		public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
-			, int stopIndex, SimulatorState initialState)
-		{
-			foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
-			{
-				if (!(listener is IParserErrorListener))
-				{
-					continue;
-				}
-				IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
-				parserErrorListener.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex
-					, initialState);
-			}
-		}
+        public virtual void ReportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex
+            , int stopIndex, SimulatorState initialState)
+        {
+            foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
+            {
+                if (!(listener is IParserErrorListener))
+                {
+                    continue;
+                }
+                IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
+                parserErrorListener.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex
+                    , initialState);
+            }
+        }
 
-		public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
-			, int stopIndex, SimulatorState acceptState)
-		{
-			foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
-			{
-				if (!(listener is IParserErrorListener))
-				{
-					continue;
-				}
-				IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
-				parserErrorListener.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex
-					, acceptState);
-			}
-		}
-	}
+        public virtual void ReportContextSensitivity(Parser recognizer, DFA dfa, int startIndex
+            , int stopIndex, SimulatorState acceptState)
+        {
+            foreach (IAntlrErrorListener<IToken> listener in GetDelegates())
+            {
+                if (!(listener is IParserErrorListener))
+                {
+                    continue;
+                }
+                IParserErrorListener parserErrorListener = (IParserErrorListener)listener;
+                parserErrorListener.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex
+                    , acceptState);
+            }
+        }
+    }
 }
diff --git a/Antlr4.Runtime/RecognitionException.cs b/Antlr4.Runtime/RecognitionException.cs
index 88fe4ffcc..0f3e67b75 100644
--- a/Antlr4.Runtime/RecognitionException.cs
+++ b/Antlr4.Runtime/RecognitionException.cs
@@ -33,123 +33,123 @@ using 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 : RuntimeException
-	{
-		private const long serialVersionUID = -3861826954750022374L;
+    /// <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 : RuntimeException
+    {
+        private const long serialVersionUID = -3861826954750022374L;
 
-		/// <summary>Who threw the exception?</summary>
-		private Recognizer<object, object> recognizer;
+        /// <summary>Who threw the exception?</summary>
+        private Recognizer<object, object> recognizer;
 
-		private RuleContext ctx;
+        private RuleContext ctx;
 
-		private IIntStream input;
+        private IIntStream input;
 
-		/// <summary>The current Token when an error occurred.</summary>
-		/// <remarks>
-		/// The current Token when an error occurred.  Since not all streams
-		/// can retrieve the ith Token, we have to track the Token object.
-		/// For parsers.  Even when it's a tree parser, token might be set.
-		/// </remarks>
-		private IToken offendingToken;
+        /// <summary>The current Token when an error occurred.</summary>
+        /// <remarks>
+        /// The current Token when an error occurred.  Since not all streams
+        /// can retrieve the ith Token, we have to track the Token object.
+        /// For parsers.  Even when it's a tree parser, token might be set.
+        /// </remarks>
+        private IToken offendingToken;
 
-		private int offendingState;
+        private int offendingState;
 
-		public RecognitionException(Lexer lexer, ICharStream input)
-		{
-			// TODO: make a dummy recognizer for the interpreter to use?
-			// Next two (ctx,input) should be what is in recognizer, but
-			// won't work when interpreting
-			this.recognizer = lexer;
-			this.input = input;
-		}
+        public RecognitionException(Lexer lexer, ICharStream input)
+        {
+            // TODO: make a dummy recognizer for the interpreter to use?
+            // Next two (ctx,input) should be what is in recognizer, but
+            // won't work when interpreting
+            this.recognizer = lexer;
+            this.input = input;
+        }
 
-		public RecognitionException(Recognizer<IToken, object> recognizer, IIntStream input
-			, ParserRuleContext ctx)
-		{
-			this.recognizer = recognizer;
-			this.input = input;
-			this.ctx = ctx;
-			if (recognizer != null)
-			{
-				this.offendingState = recognizer.GetState();
-			}
-		}
+        public RecognitionException(Recognizer<IToken, object> recognizer, IIntStream input
+            , ParserRuleContext ctx)
+        {
+            this.recognizer = recognizer;
+            this.input = input;
+            this.ctx = ctx;
+            if (recognizer != null)
+            {
+                this.offendingState = recognizer.GetState();
+            }
+        }
 
-		public RecognitionException(string message, Recognizer<IToken, object> recognizer
-			, IIntStream input, ParserRuleContext ctx) : base(message)
-		{
-			this.recognizer = recognizer;
-			this.input = input;
-			this.ctx = ctx;
-			if (recognizer != null)
-			{
-				this.offendingState = recognizer.GetState();
-			}
-		}
+        public RecognitionException(string message, Recognizer<IToken, object> recognizer
+            , IIntStream input, ParserRuleContext ctx) : base(message)
+        {
+            this.recognizer = recognizer;
+            this.input = input;
+            this.ctx = ctx;
+            if (recognizer != null)
+            {
+                this.offendingState = recognizer.GetState();
+            }
+        }
 
-		/// <summary>
-		/// Where was the parser in the ATN when the error occurred?
-		/// For No viable alternative exceptions, this is the decision state number.
-		/// </summary>
-		/// <remarks>
-		/// Where was the parser in the ATN when the error occurred?
-		/// For No viable alternative exceptions, this is the decision state number.
-		/// For others, it is the state whose emanating edge we couldn't match.
-		/// This will help us tie into the grammar and syntax diagrams in
-		/// ANTLRWorks v2.
-		/// </remarks>
-		public virtual int GetOffendingState()
-		{
-			return offendingState;
-		}
+        /// <summary>
+        /// Where was the parser in the ATN when the error occurred?
+        /// For No viable alternative exceptions, this is the decision state number.
+        /// </summary>
+        /// <remarks>
+        /// Where was the parser in the ATN when the error occurred?
+        /// For No viable alternative exceptions, this is the decision state number.
+        /// For others, it is the state whose emanating edge we couldn't match.
+        /// This will help us tie into the grammar and syntax diagrams in
+        /// ANTLRWorks v2.
+        /// </remarks>
+        public virtual int GetOffendingState()
+        {
+            return offendingState;
+        }
 
-		protected internal void SetOffendingState(int offendingState)
-		{
-			this.offendingState = offendingState;
-		}
+        protected internal void SetOffendingState(int offendingState)
+        {
+            this.offendingState = offendingState;
+        }
 
-		public virtual IntervalSet GetExpectedTokens()
-		{
-			// TODO: do we really need this type check?
-			if (recognizer is Parser)
-			{
-				return ((Parser)recognizer).GetExpectedTokens();
-			}
-			return null;
-		}
+        public virtual IntervalSet GetExpectedTokens()
+        {
+            // TODO: do we really need this type check?
+            if (recognizer is Parser)
+            {
+                return ((Parser)recognizer).GetExpectedTokens();
+            }
+            return null;
+        }
 
-		public virtual RuleContext GetCtx()
-		{
-			return ctx;
-		}
+        public virtual RuleContext GetCtx()
+        {
+            return ctx;
+        }
 
-		public virtual IIntStream GetInputStream()
-		{
-			return input;
-		}
+        public virtual IIntStream GetInputStream()
+        {
+            return input;
+        }
 
-		public virtual IToken GetOffendingToken()
-		{
-			return offendingToken;
-		}
+        public virtual IToken GetOffendingToken()
+        {
+            return offendingToken;
+        }
 
-		protected internal void SetOffendingToken(IToken offendingToken)
-		{
-			this.offendingToken = offendingToken;
-		}
+        protected internal void SetOffendingToken(IToken offendingToken)
+        {
+            this.offendingToken = offendingToken;
+        }
 
-		public virtual Recognizer<object, object> GetRecognizer()
-		{
-			return recognizer;
-		}
-	}
+        public virtual Recognizer<object, object> GetRecognizer()
+        {
+            return recognizer;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Recognizer`2.cs b/Antlr4.Runtime/Recognizer`2.cs
index aa7e5851e..aaa822988 100644
--- a/Antlr4.Runtime/Recognizer`2.cs
+++ b/Antlr4.Runtime/Recognizer`2.cs
@@ -35,185 +35,185 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public abstract class Recognizer<Symbol, ATNInterpreter> where ATNInterpreter:ATNSimulator
-	{
-		public const int Eof = -1;
+    public abstract class Recognizer<Symbol, ATNInterpreter> where ATNInterpreter:ATNSimulator
+    {
+        public const int Eof = -1;
 
-		private sealed class _CopyOnWriteArrayList_49 : CopyOnWriteArrayList<IAntlrErrorListener
-			<Symbol>>
-		{
-			public _CopyOnWriteArrayList_49()
-			{
-				{
-					this.AddItem(ConsoleErrorListener.Instance);
-				}
-			}
-		}
+        private sealed class _CopyOnWriteArrayList_49 : CopyOnWriteArrayList<IAntlrErrorListener
+            <Symbol>>
+        {
+            public _CopyOnWriteArrayList_49()
+            {
+                {
+                    this.AddItem(ConsoleErrorListener.Instance);
+                }
+            }
+        }
 
-		[NotNull]
-		private IList<IAntlrErrorListener<Symbol>> _listeners = new _CopyOnWriteArrayList_49
-			();
+        [NotNull]
+        private IList<IAntlrErrorListener<Symbol>> _listeners = new _CopyOnWriteArrayList_49
+            ();
 
-		protected internal ATNInterpreter _interp;
+        protected internal ATNInterpreter _interp;
 
-		private int _stateNumber = -1;
+        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[] GetTokenNames();
+        /// <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[] GetTokenNames();
 
-		public abstract string[] GetRuleNames();
+        public abstract string[] GetRuleNames();
 
-		/// <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 GetGrammarFileName();
+        /// <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 GetGrammarFileName();
 
-		public virtual ATN GetATN()
-		{
-			return _interp.atn;
-		}
+        public virtual ATN GetATN()
+        {
+            return _interp.atn;
+        }
 
-		public virtual ATNInterpreter GetInterpreter()
-		{
-			return _interp;
-		}
+        public virtual ATNInterpreter GetInterpreter()
+        {
+            return _interp;
+        }
 
-		public virtual void SetInterpreter(ATNInterpreter interpreter)
-		{
-			_interp = interpreter;
-		}
+        public virtual void SetInterpreter(ATNInterpreter interpreter)
+        {
+            _interp = interpreter;
+        }
 
-		/// <summary>What is the error header, normally line/character position information?</summary>
-		public virtual string GetErrorHeader(RecognitionException e)
-		{
-			int line = e.GetOffendingToken().Line;
-			int charPositionInLine = e.GetOffendingToken().Column;
-			return "line " + line + ":" + charPositionInLine;
-		}
+        /// <summary>What is the error header, normally line/character position information?</summary>
+        public virtual string GetErrorHeader(RecognitionException e)
+        {
+            int line = e.GetOffendingToken().Line;
+            int charPositionInLine = e.GetOffendingToken().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>
-		public virtual string GetTokenErrorDisplay(IToken t)
-		{
-			if (t == null)
-			{
-				return "<no token>";
-			}
-			string s = t.Text;
-			if (s == null)
-			{
-				if (t.Type == IToken.Eof)
-				{
-					s = "<EOF>";
-				}
-				else
-				{
-					s = "<" + t.Type + ">";
-				}
-			}
-			s = s.ReplaceAll("\n", "\\\\n");
-			s = s.ReplaceAll("\r", "\\\\r");
-			s = s.ReplaceAll("\t", "\\\\t");
-			return "'" + s + "'";
-		}
+        /// <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>
+        public virtual string GetTokenErrorDisplay(IToken t)
+        {
+            if (t == null)
+            {
+                return "<no token>";
+            }
+            string s = t.Text;
+            if (s == null)
+            {
+                if (t.Type == IToken.Eof)
+                {
+                    s = "<EOF>";
+                }
+                else
+                {
+                    s = "<" + t.Type + ">";
+                }
+            }
+            s = s.ReplaceAll("\n", "\\\\n");
+            s = s.ReplaceAll("\r", "\\\\r");
+            s = s.ReplaceAll("\t", "\\\\t");
+            return "'" + s + "'";
+        }
 
-		/// <exception cref="System.ArgumentNullException">
-		/// if
-		/// <code>listener</code>
-		/// is
-		/// <code>null</code>
-		/// .
-		/// </exception>
-		public virtual void AddErrorListener<_T0>(IAntlrErrorListener<_T0> listener)
-		{
-			Args.NotNull("listener", listener);
-			_listeners.AddItem(listener);
-		}
+        /// <exception cref="System.ArgumentNullException">
+        /// if
+        /// <code>listener</code>
+        /// is
+        /// <code>null</code>
+        /// .
+        /// </exception>
+        public virtual void AddErrorListener<_T0>(IAntlrErrorListener<_T0> listener)
+        {
+            Args.NotNull("listener", listener);
+            _listeners.AddItem(listener);
+        }
 
-		public virtual void RemoveErrorListener<_T0>(IAntlrErrorListener<_T0> listener)
-		{
-			_listeners.Remove(listener);
-		}
+        public virtual void RemoveErrorListener<_T0>(IAntlrErrorListener<_T0> listener)
+        {
+            _listeners.Remove(listener);
+        }
 
-		public virtual void RemoveErrorListeners()
-		{
-			_listeners.Clear();
-		}
+        public virtual void RemoveErrorListeners()
+        {
+            _listeners.Clear();
+        }
 
-		[NotNull]
-		public virtual IList<IAntlrErrorListener<Symbol>> GetErrorListeners()
-		{
-			return new List<IAntlrErrorListener<Symbol>>(_listeners);
-		}
+        [NotNull]
+        public virtual IList<IAntlrErrorListener<Symbol>> GetErrorListeners()
+        {
+            return new List<IAntlrErrorListener<Symbol>>(_listeners);
+        }
 
-		public virtual IAntlrErrorListener<Symbol> GetErrorListenerDispatch()
-		{
-			return new ProxyErrorListener<Symbol>(GetErrorListeners());
-		}
+        public virtual IAntlrErrorListener<Symbol> GetErrorListenerDispatch()
+        {
+            return new ProxyErrorListener<Symbol>(GetErrorListeners());
+        }
 
-		// 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;
-		}
+        // 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 bool Precpred(RuleContext localctx, int precedence)
+        {
+            return true;
+        }
 
-		public virtual void Action(RuleContext _localctx, int ruleIndex, int actionIndex)
-		{
-		}
+        public virtual void Action(RuleContext _localctx, int ruleIndex, int actionIndex)
+        {
+        }
 
-		public int GetState()
-		{
-			return _stateNumber;
-		}
+        public int GetState()
+        {
+            return _stateNumber;
+        }
 
-		/// <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 void SetState(int atnState)
-		{
-			//		System.err.println("setState "+atnState);
-			_stateNumber = atnState;
-		}
+        /// <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 void SetState(int atnState)
+        {
+            //		System.err.println("setState "+atnState);
+            _stateNumber = atnState;
+        }
 
-		//		if ( traceATNStates ) _ctx.trace(atnState);
-		public abstract IIntStream GetInputStream();
-	}
+        //		if ( traceATNStates ) _ctx.trace(atnState);
+        public abstract IIntStream GetInputStream();
+    }
 }
diff --git a/Antlr4.Runtime/RuleContext.cs b/Antlr4.Runtime/RuleContext.cs
index bb68d2482..bde51c6db 100644
--- a/Antlr4.Runtime/RuleContext.cs
+++ b/Antlr4.Runtime/RuleContext.cs
@@ -38,302 +38,302 @@ using Sharpen;
 
 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 and tree parsers, we use the subclass
-	/// ParserRuleContext.
-	/// </remarks>
-	/// <seealso cref="ParserRuleContext">ParserRuleContext</seealso>
-	public class RuleContext : IRuleNode
-	{
-		/// <summary>What context invoked this rule?</summary>
-		public Antlr4.Runtime.RuleContext parent;
+    /// <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 and tree parsers, we use the subclass
+    /// ParserRuleContext.
+    /// </remarks>
+    /// <seealso cref="ParserRuleContext">ParserRuleContext</seealso>
+    public class RuleContext : IRuleNode
+    {
+        /// <summary>What context invoked this rule?</summary>
+        public 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;
+        /// <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()
+        {
+        }
 
-		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 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 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;
-		}
+        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()
-		{
-			return invokingState == -1;
-		}
+        /// <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()
+        {
+            return invokingState == -1;
+        }
 
-		public virtual Interval SourceInterval
-		{
-			get
-			{
-				// satisfy the ParseTree / SyntaxTree interface
-				return Interval.Invalid;
-			}
-		}
+        public virtual Interval SourceInterval
+        {
+            get
+            {
+                // satisfy the ParseTree / SyntaxTree interface
+                return Interval.Invalid;
+            }
+        }
 
-		public virtual Antlr4.Runtime.RuleContext RuleContext
-		{
-			get
-			{
-				return this;
-			}
-		}
+        public virtual Antlr4.Runtime.RuleContext RuleContext
+        {
+            get
+            {
+                return this;
+            }
+        }
 
-		public virtual Antlr4.Runtime.RuleContext Parent
-		{
-			get
-			{
-				return parent;
-			}
-		}
+        public virtual Antlr4.Runtime.RuleContext Parent
+        {
+            get
+            {
+                return parent;
+            }
+        }
 
-		public virtual Antlr4.Runtime.RuleContext Payload
-		{
-			get
-			{
-				return this;
-			}
-		}
+        public virtual Antlr4.Runtime.RuleContext Payload
+        {
+            get
+            {
+                return this;
+            }
+        }
 
-		/// <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();
-		}
+        /// <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 GetRuleIndex()
-		{
-			return -1;
-		}
+        public virtual int GetRuleIndex()
+        {
+            return -1;
+        }
 
-		public virtual IParseTree GetChild(int i)
-		{
-			return null;
-		}
+        public virtual IParseTree GetChild(int i)
+        {
+            return null;
+        }
 
-		public virtual int ChildCount
-		{
-			get
-			{
-				return 0;
-			}
-		}
+        public virtual int ChildCount
+        {
+            get
+            {
+                return 0;
+            }
+        }
 
-		public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
-		{
-			return visitor.VisitChildren(this);
-		}
+        public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
+        {
+            return visitor.VisitChildren(this);
+        }
 
-		/// <summary>Call this method to view a parse tree in a dialog box visually.</summary>
-		/// <remarks>Call this method to view a parse tree in a dialog box visually.</remarks>
-		public virtual IFuture<JDialog> Inspect(Parser parser)
-		{
-			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
-				null;
-			return Inspect(ruleNames);
-		}
+        /// <summary>Call this method to view a parse tree in a dialog box visually.</summary>
+        /// <remarks>Call this method to view a parse tree in a dialog box visually.</remarks>
+        public virtual IFuture<JDialog> Inspect(Parser parser)
+        {
+            IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
+                null;
+            return Inspect(ruleNames);
+        }
 
-		public virtual IFuture<JDialog> Inspect(IList<string> ruleNames)
-		{
-			TreeViewer viewer = new TreeViewer(ruleNames, this);
-			return viewer.Open();
-		}
+        public virtual IFuture<JDialog> Inspect(IList<string> ruleNames)
+        {
+            TreeViewer viewer = new TreeViewer(ruleNames, this);
+            return viewer.Open();
+        }
 
-		/// <summary>Save this tree in a postscript file</summary>
-		/// <exception cref="System.IO.IOException"></exception>
-		/// <exception cref="Javax.Print.PrintException"></exception>
-		public virtual void Save(Parser parser, string fileName)
-		{
-			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
-				null;
-			Save(ruleNames, fileName);
-		}
+        /// <summary>Save this tree in a postscript file</summary>
+        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="Javax.Print.PrintException"></exception>
+        public virtual void Save(Parser parser, string fileName)
+        {
+            IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
+                null;
+            Save(ruleNames, fileName);
+        }
 
-		/// <summary>Save this tree in a postscript file using a particular font name and size
-		/// 	</summary>
-		/// <exception cref="System.IO.IOException"></exception>
-		public virtual void Save(Parser parser, string fileName, string fontName, int fontSize
-			)
-		{
-			IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
-				null;
-			Save(ruleNames, fileName, fontName, fontSize);
-		}
+        /// <summary>Save this tree in a postscript file using a particular font name and size
+        ///     </summary>
+        /// <exception cref="System.IO.IOException"></exception>
+        public virtual void Save(Parser parser, string fileName, string fontName, int fontSize
+            )
+        {
+            IList<string> ruleNames = parser != null ? Arrays.AsList(parser.GetRuleNames()) : 
+                null;
+            Save(ruleNames, fileName, fontName, fontSize);
+        }
 
-		/// <summary>Save this tree in a postscript file</summary>
-		/// <exception cref="System.IO.IOException"></exception>
-		/// <exception cref="Javax.Print.PrintException"></exception>
-		public virtual void Save(IList<string> ruleNames, string fileName)
-		{
-			Trees.WritePS(this, ruleNames, fileName);
-		}
+        /// <summary>Save this tree in a postscript file</summary>
+        /// <exception cref="System.IO.IOException"></exception>
+        /// <exception cref="Javax.Print.PrintException"></exception>
+        public virtual void Save(IList<string> ruleNames, string fileName)
+        {
+            Trees.WritePS(this, ruleNames, fileName);
+        }
 
-		/// <summary>Save this tree in a postscript file using a particular font name and size
-		/// 	</summary>
-		/// <exception cref="System.IO.IOException"></exception>
-		public virtual void Save(IList<string> ruleNames, string fileName, string fontName
-			, int fontSize)
-		{
-			Trees.WritePS(this, ruleNames, fileName, fontName, fontSize);
-		}
+        /// <summary>Save this tree in a postscript file using a particular font name and size
+        ///     </summary>
+        /// <exception cref="System.IO.IOException"></exception>
+        public virtual void Save(IList<string> ruleNames, string fileName, string fontName
+            , int fontSize)
+        {
+            Trees.WritePS(this, ruleNames, fileName, fontName, fontSize);
+        }
 
-		/// <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.
+        /// 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);
-		}
+        /// <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 virtual string ToStringTree()
+        {
+            return ToStringTree((IList<string>)null);
+        }
 
-		public override string ToString()
-		{
-			return ToString((IList<string>)null, (Antlr4.Runtime.RuleContext)null);
-		}
+        public override string ToString()
+        {
+            return ToString((IList<string>)null, (Antlr4.Runtime.RuleContext)null);
+        }
 
-		public string ToString<_T0>(Recognizer<_T0> recog)
-		{
-			return ToString(recog, ParserRuleContext.EmptyContext());
-		}
+        public string ToString<_T0>(Recognizer<_T0> recog)
+        {
+            return ToString(recog, ParserRuleContext.EmptyContext());
+        }
 
-		public string ToString(IList<string> ruleNames)
-		{
-			return ToString(ruleNames, null);
-		}
+        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<_T0>(Recognizer<_T0> recog, Antlr4.Runtime.RuleContext
-			 stop)
-		{
-			string[] ruleNames = recog != null ? recog.GetRuleNames() : null;
-			IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
-			return ToString(ruleNamesList, stop);
-		}
+        // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+        public virtual string ToString<_T0>(Recognizer<_T0> recog, Antlr4.Runtime.RuleContext
+             stop)
+        {
+            string[] ruleNames = recog != null ? recog.GetRuleNames() : 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.GetRuleIndex();
-					string ruleName = ruleIndex >= 0 && ruleIndex < ruleNames.Count ? ruleNames[ruleIndex
-						] : Sharpen.Extensions.ToString(ruleIndex);
-					buf.Append(ruleName);
-				}
-				if (p.parent != null && (ruleNames != null || !p.parent.IsEmpty()))
-				{
-					buf.Append(" ");
-				}
-				p = p.parent;
-			}
-			buf.Append("]");
-			return buf.ToString();
-		}
-	}
+        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.GetRuleIndex();
+                    string ruleName = ruleIndex >= 0 && ruleIndex < ruleNames.Count ? ruleNames[ruleIndex
+                        ] : Sharpen.Extensions.ToString(ruleIndex);
+                    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/Antlr4.Runtime/TokenStreamRewriter.cs b/Antlr4.Runtime/TokenStreamRewriter.cs
index ac71f1744..80b6b0446 100644
--- a/Antlr4.Runtime/TokenStreamRewriter.cs
+++ b/Antlr4.Runtime/TokenStreamRewriter.cs
@@ -36,710 +36,710 @@ using 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.
-	/// 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. :)
-	/// 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.
-	/// 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.
-	/// 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.
-	/// 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,
-	/// 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();
-	/// 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());
-	/// 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:
-	/// 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"));
-	/// If you don't use named rewrite streams, a "default" stream is used as
-	/// the first example shows.
-	/// </remarks>
-	public class TokenStreamRewriter
-	{
-		public static readonly string DefaultProgramName = "default";
+    /// <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.
+    /// 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. :)
+    /// 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.
+    /// 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.
+    /// 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.
+    /// 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,
+    /// 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();
+    /// 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());
+    /// 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:
+    /// 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"));
+    /// If you don't use named rewrite streams, a "default" stream is used as
+    /// the first example shows.
+    /// </remarks>
+    public class TokenStreamRewriter
+    {
+        public static readonly string DefaultProgramName = "default";
 
-		public const int ProgramInitSize = 100;
+        public const int ProgramInitSize = 100;
 
-		public const int MinTokenIndex = 0;
+        public const int MinTokenIndex = 0;
 
-		public class RewriteOperation
-		{
-			protected internal readonly ITokenStream tokens;
+        public class RewriteOperation
+        {
+            protected internal readonly ITokenStream tokens;
 
-			/// <summary>What index into rewrites List are we?</summary>
-			protected internal int instructionIndex;
+            /// <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;
+            /// <summary>Token buffer index.</summary>
+            /// <remarks>Token buffer index.</remarks>
+            protected internal int index;
 
-			protected internal object text;
+            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)
+            {
+                // 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;
-			}
+            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;
-			}
+            /// <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 + "\">";
-			}
-		}
+            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
-		{
-			protected internal InsertBeforeOp(ITokenStream tokens, int index, object text) : 
-				base(tokens, index, text)
-			{
-			}
+        internal class InsertBeforeOp : TokenStreamRewriter.RewriteOperation
+        {
+            protected internal 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 != IToken.Eof)
-				{
-					buf.Append(tokens.Get(index).Text);
-				}
-				return index + 1;
-			}
-		}
+            public override int Execute(StringBuilder buf)
+            {
+                buf.Append(text);
+                if (tokens.Get(index).Type != IToken.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;
+        /// <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 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 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 + "\">";
-			}
-		}
+            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>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) -&gt; rewrite (List)
-		/// </remarks>
-		protected internal readonly IDictionary<string, IList<TokenStreamRewriter.RewriteOperation
-			>> programs;
+        /// <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) -&gt; rewrite (List)
+        /// </remarks>
+        protected internal readonly IDictionary<string, IList<TokenStreamRewriter.RewriteOperation
+            >> programs;
 
-		/// <summary>Map String (program name) -&gt; Integer index</summary>
-		protected internal readonly IDictionary<string, int> lastRewriteTokenIndexes;
+        /// <summary>Map String (program name) -&gt; 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.Put(DefaultProgramName, new List<TokenStreamRewriter.RewriteOperation>(ProgramInitSize
-				));
-			lastRewriteTokenIndexes = new Dictionary<string, int>();
-		}
+        public TokenStreamRewriter(ITokenStream tokens)
+        {
+            this.tokens = tokens;
+            programs = new Dictionary<string, IList<TokenStreamRewriter.RewriteOperation>>();
+            programs.Put(DefaultProgramName, new List<TokenStreamRewriter.RewriteOperation>(ProgramInitSize
+                ));
+            lastRewriteTokenIndexes = new Dictionary<string, int>();
+        }
 
-		public ITokenStream GetTokenStream()
-		{
-			return tokens;
-		}
+        public ITokenStream GetTokenStream()
+        {
+            return tokens;
+        }
 
-		public virtual void Rollback(int instructionIndex)
-		{
-			Rollback(DefaultProgramName, instructionIndex);
-		}
+        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 = programs.Get(programName);
-			if (@is != null)
-			{
-				programs.Put(programName, @is.SubList(MinTokenIndex, 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 = programs.Get(programName);
+            if (@is != null)
+            {
+                programs.Put(programName, @is.SubList(MinTokenIndex, instructionIndex));
+            }
+        }
 
-		public virtual void DeleteProgram()
-		{
-			DeleteProgram(DefaultProgramName);
-		}
+        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);
-		}
+        /// <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(IToken t, object text)
+        {
+            InsertAfter(DefaultProgramName, t, text);
+        }
 
-		public virtual void InsertAfter(int index, object text)
-		{
-			InsertAfter(DefaultProgramName, index, 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, 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 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(IToken t, object text)
+        {
+            InsertBefore(DefaultProgramName, t, text);
+        }
 
-		public virtual void InsertBefore(int index, object text)
-		{
-			InsertBefore(DefaultProgramName, index, 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, 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.AddItem(op);
-		}
+        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.AddItem(op);
+        }
 
-		public virtual void Replace(int index, object text)
-		{
-			Replace(DefaultProgramName, index, index, text);
-		}
+        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(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 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(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.AddItem(op);
-		}
+        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.AddItem(op);
+        }
 
-		public virtual void Replace(string programName, IToken from, IToken to, object text
-			)
-		{
-			Replace(programName, from.TokenIndex, to.TokenIndex, text);
-		}
+        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 index)
+        {
+            Delete(DefaultProgramName, index, index);
+        }
 
-		public virtual void Delete(int from, int to)
-		{
-			Delete(DefaultProgramName, from, to);
-		}
+        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 indexT)
+        {
+            Delete(DefaultProgramName, indexT, indexT);
+        }
 
-		public virtual void Delete(IToken from, IToken to)
-		{
-			Delete(DefaultProgramName, from, to);
-		}
+        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, 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 void Delete(string programName, IToken from, IToken to)
+        {
+            Replace(programName, from, to, null);
+        }
 
-		public virtual int GetLastRewriteTokenIndex()
-		{
-			return GetLastRewriteTokenIndex(DefaultProgramName);
-		}
+        public virtual int GetLastRewriteTokenIndex()
+        {
+            return GetLastRewriteTokenIndex(DefaultProgramName);
+        }
 
-		protected internal virtual int GetLastRewriteTokenIndex(string programName)
-		{
-			int I = lastRewriteTokenIndexes.Get(programName);
-			if (I == null)
-			{
-				return -1;
-			}
-			return I;
-		}
+        protected internal virtual int GetLastRewriteTokenIndex(string programName)
+        {
+            int I = lastRewriteTokenIndexes.Get(programName);
+            if (I == null)
+            {
+                return -1;
+            }
+            return I;
+        }
 
-		protected internal virtual void SetLastRewriteTokenIndex(string programName, int 
-			i)
-		{
-			lastRewriteTokenIndexes.Put(programName, i);
-		}
+        protected internal virtual void SetLastRewriteTokenIndex(string programName, int 
+            i)
+        {
+            lastRewriteTokenIndexes.Put(programName, i);
+        }
 
-		protected internal virtual IList<TokenStreamRewriter.RewriteOperation> GetProgram
-			(string name)
-		{
-			IList<TokenStreamRewriter.RewriteOperation> @is = programs.Get(name);
-			if (@is == null)
-			{
-				@is = InitializeProgram(name);
-			}
-			return @is;
-		}
+        protected internal virtual IList<TokenStreamRewriter.RewriteOperation> GetProgram
+            (string name)
+        {
+            IList<TokenStreamRewriter.RewriteOperation> @is = programs.Get(name);
+            if (@is == null)
+            {
+                @is = InitializeProgram(name);
+            }
+            return @is;
+        }
 
-		private IList<TokenStreamRewriter.RewriteOperation> InitializeProgram(string name
-			)
-		{
-			IList<TokenStreamRewriter.RewriteOperation> @is = new List<TokenStreamRewriter.RewriteOperation
-				>(ProgramInitSize);
-			programs.Put(name, @is);
-			return @is;
-		}
+        private IList<TokenStreamRewriter.RewriteOperation> InitializeProgram(string name
+            )
+        {
+            IList<TokenStreamRewriter.RewriteOperation> @is = new List<TokenStreamRewriter.RewriteOperation
+                >(ProgramInitSize);
+            programs.Put(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 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);
-		}
+        /// <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 = programs.Get(programName);
-			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.IsEmpty())
-			{
-				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 = indexToOp.Get(i);
-				Sharpen.Collections.Remove(indexToOp, 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 != IToken.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();
-		}
+        public virtual string GetText(string programName, Interval interval)
+        {
+            IList<TokenStreamRewriter.RewriteOperation> rewrites = programs.Get(programName);
+            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.IsEmpty())
+            {
+                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 = indexToOp.Get(i);
+                Sharpen.Collections.Remove(indexToOp, 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 != IToken.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 -&gt; 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.Set(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.Set(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.Set(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.Set(prevRop.instructionIndex, null);
-						// kill first delete
-						rop.index = Math.Min(prevRop.index, rop.index);
-						rop.lastIndex = Math.Max(prevRop.lastIndex, rop.lastIndex);
-						System.Console.Out.WriteLine("new rop " + rop);
-					}
-					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.Set(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.Set(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.Get(op.index) != null)
-				{
-					throw new Error("should only be one op per index");
-				}
-				m.Put(op.index, op);
-			}
-			//System.out.println("index to op: "+m);
-			return m;
-		}
+        /// <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 -&gt; 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.Set(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.Set(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.Set(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.Set(prevRop.instructionIndex, null);
+                        // kill first delete
+                        rop.index = Math.Min(prevRop.index, rop.index);
+                        rop.lastIndex = Math.Max(prevRop.lastIndex, rop.lastIndex);
+                        System.Console.Out.WriteLine("new rop " + rop);
+                    }
+                    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.Set(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.Set(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.Get(op.index) != null)
+                {
+                    throw new Error("should only be one op per index");
+                }
+                m.Put(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;
-		}
+        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, _T1>(IList<_T1> rewrites, int
-			 before) where T:TokenStreamRewriter.RewriteOperation where _T1:TokenStreamRewriter.RewriteOperation
-		{
-			System.Type kind = typeof(T);
-			IList<T> ops = new List<T>();
-			for (int i = 0; i < before && i < rewrites.Count; i++)
-			{
-				TokenStreamRewriter.RewriteOperation op = rewrites[i];
-				if (op == null)
-				{
-					continue;
-				}
-				// ignore deleted
-				if (kind.IsInstanceOfType(op))
-				{
-					ops.AddItem(kind.Cast(op));
-				}
-			}
-			return ops;
-		}
-	}
+        /// <summary>Get all operations before an index of a particular kind</summary>
+        protected internal virtual IList<T> GetKindOfOps<T, _T1>(IList<_T1> rewrites, int
+             before) where T:TokenStreamRewriter.RewriteOperation where _T1:TokenStreamRewriter.RewriteOperation
+        {
+            System.Type kind = typeof(T);
+            IList<T> ops = new List<T>();
+            for (int i = 0; i < before && i < rewrites.Count; i++)
+            {
+                TokenStreamRewriter.RewriteOperation op = rewrites[i];
+                if (op == null)
+                {
+                    continue;
+                }
+                // ignore deleted
+                if (kind.IsInstanceOfType(op))
+                {
+                    ops.AddItem(kind.Cast(op));
+                }
+            }
+            return ops;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
index 1e5b6150d..29b3dd92b 100644
--- a/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
+++ b/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
@@ -32,202 +32,202 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public abstract class AbstractParseTreeVisitor<Result> : IParseTreeVisitor<Result
-		>
-	{
-		/// <summary>
-		/// <inheritDoc></inheritDoc>
-		/// <p/>
-		/// The default implementation calls
-		/// <see cref="IParseTree.Accept{T}(IParseTreeVisitor{Result})">IParseTree.Accept&lt;T&gt;(IParseTreeVisitor&lt;Result&gt;)
-		/// 	</see>
-		/// on the
-		/// specified tree.
-		/// </summary>
-		public virtual Result Visit(IParseTree tree)
-		{
-			return tree.Accept(this);
-		}
+    public abstract class AbstractParseTreeVisitor<Result> : IParseTreeVisitor<Result
+        >
+    {
+        /// <summary>
+        /// <inheritDoc></inheritDoc>
+        /// <p/>
+        /// The default implementation calls
+        /// <see cref="IParseTree.Accept{T}(IParseTreeVisitor{Result})">IParseTree.Accept&lt;T&gt;(IParseTreeVisitor&lt;Result&gt;)
+        ///     </see>
+        /// on the
+        /// specified tree.
+        /// </summary>
+        public virtual Result Visit(IParseTree tree)
+        {
+            return tree.Accept(this);
+        }
 
-		/// <summary>
-		/// <inheritDoc></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, object)
-		/// 	">shouldVisitNextChild</see>
-		/// ; if the result
-		/// is
-		/// <code>false</code>
-		/// 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(object, object)">aggregateResult
-		/// 	</see>
-		/// with the
-		/// previous aggregate result and the result of visiting the child.
-		/// </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></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, object)
+        ///     ">shouldVisitNextChild</see>
+        /// ; if the result
+        /// is
+        /// <code>false</code>
+        /// 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(object, object)">aggregateResult
+        ///     </see>
+        /// with the
+        /// previous aggregate result and the result of visiting the child.
+        /// </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></inheritDoc>
-		/// <p/>
-		/// The default implementation returns the result of
-		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
-		/// .
-		/// </summary>
-		public virtual Result VisitTerminal(ITerminalNode node)
-		{
-			return DefaultResult();
-		}
+        /// <summary>
+        /// <inheritDoc></inheritDoc>
+        /// <p/>
+        /// The default implementation returns the result of
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
+        /// .
+        /// </summary>
+        public virtual Result VisitTerminal(ITerminalNode node)
+        {
+            return DefaultResult();
+        }
 
-		/// <summary>
-		/// <inheritDoc></inheritDoc>
-		/// <p/>
-		/// The default implementation returns the result of
-		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
-		/// .
-		/// </summary>
-		public virtual Result VisitErrorNode(IErrorNode node)
-		{
-			return DefaultResult();
-		}
+        /// <summary>
+        /// <inheritDoc></inheritDoc>
+        /// <p/>
+        /// The default implementation returns the result of
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult</see>
+        /// .
+        /// </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
-		/// <code>null</code>
-		/// .
-		/// </remarks>
-		/// <returns>The default value returned by visitor methods.</returns>
-		protected internal virtual Result DefaultResult()
-		{
-			return null;
-		}
+        /// <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
+        /// <code>null</code>
+        /// .
+        /// </remarks>
+        /// <returns>The default value returned by visitor methods.</returns>
+        protected internal virtual Result DefaultResult()
+        {
+            return null;
+        }
 
-		/// <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, object)
-		/// 	">AbstractParseTreeVisitor&lt;Result&gt;.ShouldVisitNextChild(IRuleNode, object)
-		/// 	</see>
-		/// returns
-		/// <code>false</code>
-		/// , the aggregate value is returned as the result of
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
-		/// 	</see>
-		/// .
-		/// <p/>
-		/// The default implementation returns
-		/// <code>nextResult</code>
-		/// , meaning
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
-		/// 	</see>
-		/// will return the result of the last child visited
-		/// (or return the initial value if the node has no children).
-		/// </remarks>
-		/// <param name="aggregate">
-		/// The previous aggregate value. In the default
-		/// implementation, the aggregate value is initialized to
-		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">AbstractParseTreeVisitor&lt;Result&gt;.DefaultResult()
-		/// 	</see>
-		/// , which is passed as the
-		/// <code>aggregate</code>
-		/// 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>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, object)
+        ///     ">AbstractParseTreeVisitor&lt;Result&gt;.ShouldVisitNextChild(IRuleNode, object)
+        ///     </see>
+        /// returns
+        /// <code>false</code>
+        /// , the aggregate value is returned as the result of
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
+        ///     </see>
+        /// .
+        /// <p/>
+        /// The default implementation returns
+        /// <code>nextResult</code>
+        /// , meaning
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
+        ///     </see>
+        /// will return the result of the last child visited
+        /// (or return the initial value if the node has no children).
+        /// </remarks>
+        /// <param name="aggregate">
+        /// The previous aggregate value. In the default
+        /// implementation, the aggregate value is initialized to
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">AbstractParseTreeVisitor&lt;Result&gt;.DefaultResult()
+        ///     </see>
+        /// , which is passed as the
+        /// <code>aggregate</code>
+        /// 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)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
-		/// 	</see>
-		/// . This method is first called before the first
-		/// child is visited; at that point
-		/// <code>currentResult</code>
-		/// will be the initial
-		/// value (in the default implementation, the initial value is returned by a
-		/// call to
-		/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">AbstractParseTreeVisitor&lt;Result&gt;.DefaultResult()
-		/// 	</see>
-		/// . This method is not called after the last
-		/// child is visited.
-		/// <p/>
-		/// The default implementation always returns
-		/// <code>true</code>
-		/// , indicating that
-		/// <code>visitChildren</code>
-		/// 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.
-		/// </summary>
-		/// <param name="node">
-		/// The
-		/// <see cref="IRuleNode">IRuleNode</see>
-		/// whose children are currently being
-		/// visited.
-		/// </param>
-		/// <param name="currentResult">
-		/// The current aggregate result of the children visited
-		/// to the current point.
-		/// </param>
-		/// <returns>
-		/// 
-		/// <code>true</code>
-		/// to continue visiting children. Otherwise return
-		/// <code>false</code>
-		/// to stop visiting children and immediately return the
-		/// current aggregate result from
-		/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
-		/// 	</see>
-		/// .
-		/// </returns>
-		protected internal virtual bool ShouldVisitNextChild(IRuleNode node, Result currentResult
-			)
-		{
-			return true;
-		}
-	}
+        /// <summary>
+        /// This method is called after visiting each child in
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
+        ///     </see>
+        /// . This method is first called before the first
+        /// child is visited; at that point
+        /// <code>currentResult</code>
+        /// will be the initial
+        /// value (in the default implementation, the initial value is returned by a
+        /// call to
+        /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">AbstractParseTreeVisitor&lt;Result&gt;.DefaultResult()
+        ///     </see>
+        /// . This method is not called after the last
+        /// child is visited.
+        /// <p/>
+        /// The default implementation always returns
+        /// <code>true</code>
+        /// , indicating that
+        /// <code>visitChildren</code>
+        /// 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.
+        /// </summary>
+        /// <param name="node">
+        /// The
+        /// <see cref="IRuleNode">IRuleNode</see>
+        /// whose children are currently being
+        /// visited.
+        /// </param>
+        /// <param name="currentResult">
+        /// The current aggregate result of the children visited
+        /// to the current point.
+        /// </param>
+        /// <returns>
+        /// 
+        /// <code>true</code>
+        /// to continue visiting children. Otherwise return
+        /// <code>false</code>
+        /// to stop visiting children and immediately return the
+        /// current aggregate result from
+        /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">AbstractParseTreeVisitor&lt;Result&gt;.VisitChildren(IRuleNode)
+        ///     </see>
+        /// .
+        /// </returns>
+        protected internal virtual bool ShouldVisitNextChild(IRuleNode node, Result currentResult
+            )
+        {
+            return true;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
index f7b545b9d..265a4b646 100644
--- a/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/ErrorNodeImpl.cs
@@ -33,26 +33,26 @@ using Sharpen;
 
 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)
-		{
-		}
+    /// <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, _T1>(IParseTreeVisitor<_T1> visitor)
-		{
-			return visitor.VisitErrorNode(this);
-		}
-	}
+        public override T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor)
+        {
+            return visitor.VisitErrorNode(this);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/IErrorNode.cs b/Antlr4.Runtime/Tree/IErrorNode.cs
index 1e6caed4a..b03519d6d 100644
--- a/Antlr4.Runtime/Tree/IErrorNode.cs
+++ b/Antlr4.Runtime/Tree/IErrorNode.cs
@@ -32,7 +32,7 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface IErrorNode : ITerminalNode
-	{
-	}
+    public interface IErrorNode : ITerminalNode
+    {
+    }
 }
diff --git a/Antlr4.Runtime/Tree/IParseTree.cs b/Antlr4.Runtime/Tree/IParseTree.cs
index d6530fcf3..00eec1a7f 100644
--- a/Antlr4.Runtime/Tree/IParseTree.cs
+++ b/Antlr4.Runtime/Tree/IParseTree.cs
@@ -33,53 +33,53 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	/// <summary>
-	/// An interface to access the tree of
-	/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
-	/// 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">Antlr4.Runtime.IToken</see>
-	/// or a
-	/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
-	/// object.
-	/// </summary>
-	public interface IParseTree : ISyntaxTree
-	{
-		IParseTree Parent
-		{
-			get;
-		}
+    /// <summary>
+    /// An interface to access the tree of
+    /// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+    /// 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">Antlr4.Runtime.IToken</see>
+    /// or a
+    /// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+    /// object.
+    /// </summary>
+    public interface IParseTree : ISyntaxTree
+    {
+        IParseTree Parent
+        {
+            get;
+        }
 
-		// the following methods narrow the return type; they are not additional methods
-		IParseTree GetChild(int i);
+        // the following methods narrow the return type; they are not additional methods
+        IParseTree GetChild(int i);
 
-		/// <summary>
-		/// The
-		/// <see cref="IParseTreeVisitor{Result}">IParseTreeVisitor&lt;Result&gt;</see>
-		/// needs a double dispatch method.
-		/// </summary>
-		T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T;
+        /// <summary>
+        /// The
+        /// <see cref="IParseTreeVisitor{Result}">IParseTreeVisitor&lt;Result&gt;</see>
+        /// needs a double dispatch method.
+        /// </summary>
+        T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T;
 
-		/// <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>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);
-	}
+        /// <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/Antlr4.Runtime/Tree/IParseTreeListener.cs b/Antlr4.Runtime/Tree/IParseTreeListener.cs
index 1865dee64..b5431ad3a 100644
--- a/Antlr4.Runtime/Tree/IParseTreeListener.cs
+++ b/Antlr4.Runtime/Tree/IParseTreeListener.cs
@@ -33,14 +33,14 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface IParseTreeListener
-	{
-		void VisitTerminal(ITerminalNode node);
+    public interface IParseTreeListener
+    {
+        void VisitTerminal(ITerminalNode node);
 
-		void VisitErrorNode(IErrorNode node);
+        void VisitErrorNode(IErrorNode node);
 
-		void EnterEveryRule(ParserRuleContext ctx);
+        void EnterEveryRule(ParserRuleContext ctx);
 
-		void ExitEveryRule(ParserRuleContext ctx);
-	}
+        void ExitEveryRule(ParserRuleContext ctx);
+    }
 }
diff --git a/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs b/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
index 9104a5325..115d098c2 100644
--- a/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
+++ b/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
@@ -32,66 +32,66 @@ using Sharpen;
 
 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
-	/// <code>XVisitor</code>
-	/// interface for
-	/// grammar
-	/// <code>X</code>
-	/// .
-	/// </remarks>
-	/// <author>Sam Harwell</author>
-	/// <?></?>
-	public interface IParseTreeVisitor<Result>
-	{
-		/// <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">IParseTree</see>
-		/// to visit.
-		/// </param>
-		/// <returns>The result of visiting the parse tree.</returns>
-		Result Visit(IParseTree 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
+    /// <code>XVisitor</code>
+    /// interface for
+    /// grammar
+    /// <code>X</code>
+    /// .
+    /// </remarks>
+    /// <author>Sam Harwell</author>
+    /// <?></?>
+    public interface IParseTreeVisitor<Result>
+    {
+        /// <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">IParseTree</see>
+        /// 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">IRuleNode</see>
-		/// whose children should be visited.
-		/// </param>
-		/// <returns>The result of visiting the children of the node.</returns>
-		Result VisitChildren(IRuleNode node);
+        /// <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">IRuleNode</see>
+        /// 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">ITerminalNode</see>
-		/// to visit.
-		/// </param>
-		/// <returns>The result of visiting the node.</returns>
-		Result VisitTerminal(ITerminalNode 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">ITerminalNode</see>
+        /// 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">IErrorNode</see>
-		/// to visit.
-		/// </param>
-		/// <returns>The result of visiting the node.</returns>
-		Result VisitErrorNode(IErrorNode 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">IErrorNode</see>
+        /// to visit.
+        /// </param>
+        /// <returns>The result of visiting the node.</returns>
+        Result VisitErrorNode(IErrorNode node);
+    }
 }
diff --git a/Antlr4.Runtime/Tree/IRuleNode.cs b/Antlr4.Runtime/Tree/IRuleNode.cs
index c7098d0d6..0ccd605f6 100644
--- a/Antlr4.Runtime/Tree/IRuleNode.cs
+++ b/Antlr4.Runtime/Tree/IRuleNode.cs
@@ -32,16 +32,16 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface IRuleNode : IParseTree
-	{
-		Antlr4.Runtime.RuleContext RuleContext
-		{
-			get;
-		}
+    public interface IRuleNode : IParseTree
+    {
+        Antlr4.Runtime.RuleContext RuleContext
+        {
+            get;
+        }
 
-		IRuleNode Parent
-		{
-			get;
-		}
-	}
+        IRuleNode Parent
+        {
+            get;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/ISyntaxTree.cs b/Antlr4.Runtime/Tree/ISyntaxTree.cs
index ef2ca13f1..c6c6f4276 100644
--- a/Antlr4.Runtime/Tree/ISyntaxTree.cs
+++ b/Antlr4.Runtime/Tree/ISyntaxTree.cs
@@ -33,34 +33,34 @@ using Sharpen;
 
 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">Antlr4.Runtime.Misc.Interval</see>
-		/// indicating the index in the
-		/// <see cref="Antlr4.Runtime.ITokenStream">Antlr4.Runtime.ITokenStream</see>
-		/// 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">Antlr4.Runtime.Misc.Interval.Invalid
-		/// 	</see>
-		/// .
-		/// </summary>
-		Interval SourceInterval
-		{
-			get;
-		}
-	}
+    /// <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">Antlr4.Runtime.Misc.Interval</see>
+        /// indicating the index in the
+        /// <see cref="Antlr4.Runtime.ITokenStream">Antlr4.Runtime.ITokenStream</see>
+        /// 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">Antlr4.Runtime.Misc.Interval.Invalid
+        ///     </see>
+        /// .
+        /// </summary>
+        Interval SourceInterval
+        {
+            get;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/ITerminalNode.cs b/Antlr4.Runtime/Tree/ITerminalNode.cs
index b086eb541..03f0a226e 100644
--- a/Antlr4.Runtime/Tree/ITerminalNode.cs
+++ b/Antlr4.Runtime/Tree/ITerminalNode.cs
@@ -33,16 +33,16 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public interface ITerminalNode : IParseTree
-	{
-		IToken Symbol
-		{
-			get;
-		}
+    public interface ITerminalNode : IParseTree
+    {
+        IToken Symbol
+        {
+            get;
+        }
 
-		IRuleNode Parent
-		{
-			get;
-		}
-	}
+        IRuleNode Parent
+        {
+            get;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/ITree.cs b/Antlr4.Runtime/Tree/ITree.cs
index f71b11c59..2b4f6adf0 100644
--- a/Antlr4.Runtime/Tree/ITree.cs
+++ b/Antlr4.Runtime/Tree/ITree.cs
@@ -32,67 +32,67 @@ using Sharpen;
 
 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>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">Antlr4.Runtime.IToken</see>
-		/// representing
-		/// a leaf node or a
-		/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
-		/// object representing a rule
-		/// invocation. For abstract syntax trees (ASTs), this is a
-		/// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
-		/// object.
-		/// </remarks>
-		object Payload
-		{
-			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">Antlr4.Runtime.IToken</see>
+        /// representing
+        /// a leaf node or a
+        /// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+        /// object representing a rule
+        /// invocation. For abstract syntax trees (ASTs), this is a
+        /// <see cref="Antlr4.Runtime.IToken">Antlr4.Runtime.IToken</see>
+        /// object.
+        /// </remarks>
+        object Payload
+        {
+            get;
+        }
 
-		/// <summary>
-		/// If there are children, get the
-		/// <code>i</code>
-		/// th value indexed from 0.
-		/// </summary>
-		ITree GetChild(int i);
+        /// <summary>
+        /// If there are children, get the
+        /// <code>i</code>
+        /// 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>
+        /// 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
-		/// <code>(root child1 .. childN)</code>
-		/// . Print just a node if this is a leaf.
-		/// </summary>
-		string ToStringTree();
-	}
+        /// <summary>
+        /// Print out a whole tree, not just a node, in LISP format
+        /// <code>(root child1 .. childN)</code>
+        /// . Print just a node if this is a leaf.
+        /// </summary>
+        string ToStringTree();
+    }
 }
diff --git a/Antlr4.Runtime/Tree/ParseTreeProperty`1.cs b/Antlr4.Runtime/Tree/ParseTreeProperty`1.cs
index a1f9fd41b..0acf3fc2a 100644
--- a/Antlr4.Runtime/Tree/ParseTreeProperty`1.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeProperty`1.cs
@@ -33,39 +33,39 @@ using Sharpen;
 
 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 IDictionary<IParseTree, V> annotations = new IdentityHashMap<IParseTree
-			, V>();
+    /// <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 IDictionary<IParseTree, V> annotations = new IdentityHashMap<IParseTree
+            , V>();
 
-		public virtual V Get(IParseTree node)
-		{
-			return annotations.Get(node);
-		}
+        public virtual V Get(IParseTree node)
+        {
+            return annotations.Get(node);
+        }
 
-		public virtual void Put(IParseTree node, V value)
-		{
-			annotations.Put(node, value);
-		}
+        public virtual void Put(IParseTree node, V value)
+        {
+            annotations.Put(node, value);
+        }
 
-		public virtual V RemoveFrom(IParseTree node)
-		{
-			return Sharpen.Collections.Remove(annotations, node);
-		}
-	}
+        public virtual V RemoveFrom(IParseTree node)
+        {
+            return Sharpen.Collections.Remove(annotations, node);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/ParseTreeWalker.cs b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
index 53e0a1673..6992869ae 100644
--- a/Antlr4.Runtime/Tree/ParseTreeWalker.cs
+++ b/Antlr4.Runtime/Tree/ParseTreeWalker.cs
@@ -33,58 +33,58 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public class ParseTreeWalker
-	{
-		public static readonly ParseTreeWalker Default = new ParseTreeWalker();
+    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);
-		}
+        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)">IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)
-		/// 	</see>
-		/// and a
-		/// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
-		/// -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);
-		}
+        /// <summary>
+        /// The discovery of a rule node, involves sending two events: the generic
+        /// <see cref="IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)">IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)
+        ///     </see>
+        /// and a
+        /// <see cref="Antlr4.Runtime.RuleContext">Antlr4.Runtime.RuleContext</see>
+        /// -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);
-		}
-	}
+        protected internal virtual void ExitRule(IParseTreeListener listener, IRuleNode r
+            )
+        {
+            ParserRuleContext ctx = (ParserRuleContext)r.RuleContext;
+            ctx.ExitRule(listener);
+            listener.ExitEveryRule(ctx);
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
index db338eb15..7c62af211 100644
--- a/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
+++ b/Antlr4.Runtime/Tree/TerminalNodeImpl.cs
@@ -34,105 +34,105 @@ using Sharpen;
 
 namespace Antlr4.Runtime.Tree
 {
-	public class TerminalNodeImpl : ITerminalNode
-	{
-		public IToken symbol;
+    public class TerminalNodeImpl : ITerminalNode
+    {
+        public IToken symbol;
 
-		public IRuleNode parent;
+        public IRuleNode parent;
 
-		public TerminalNodeImpl(IToken symbol)
-		{
-			this.symbol = symbol;
-		}
+        public TerminalNodeImpl(IToken symbol)
+        {
+            this.symbol = symbol;
+        }
 
-		public virtual IParseTree GetChild(int i)
-		{
-			return null;
-		}
+        public virtual IParseTree GetChild(int i)
+        {
+            return null;
+        }
 
-		public virtual IToken Symbol
-		{
-			get
-			{
-				return symbol;
-			}
-		}
+        public virtual IToken Symbol
+        {
+            get
+            {
+                return symbol;
+            }
+        }
 
-		public virtual IRuleNode Parent
-		{
-			get
-			{
-				return parent;
-			}
-		}
+        public virtual IRuleNode Parent
+        {
+            get
+            {
+                return parent;
+            }
+        }
 
-		public virtual IToken Payload
-		{
-			get
-			{
-				return symbol;
-			}
-		}
+        public virtual IToken Payload
+        {
+            get
+            {
+                return symbol;
+            }
+        }
 
-		public virtual Interval SourceInterval
-		{
-			get
-			{
-				if (symbol != null)
-				{
-					int tokenIndex = symbol.TokenIndex;
-					return new Interval(tokenIndex, tokenIndex);
-				}
-				return Interval.Invalid;
-			}
-		}
+        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 int ChildCount
+        {
+            get
+            {
+                return 0;
+            }
+        }
 
-		public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
-		{
-			return visitor.VisitTerminal(this);
-		}
+        public virtual T Accept<T, _T1>(IParseTreeVisitor<_T1> visitor) where _T1:T
+        {
+            return visitor.VisitTerminal(this);
+        }
 
-		public virtual string GetText()
-		{
-			if (symbol != null)
-			{
-				return symbol.Text;
-			}
-			return null;
-		}
+        public virtual string GetText()
+        {
+            if (symbol != null)
+            {
+                return symbol.Text;
+            }
+            return null;
+        }
 
-		public virtual string ToStringTree(Parser parser)
-		{
-			return ToString();
-		}
+        public virtual string ToStringTree(Parser parser)
+        {
+            return ToString();
+        }
 
-		public override string ToString()
-		{
-			if (symbol != null)
-			{
-				if (symbol.Type == IToken.Eof)
-				{
-					return "<EOF>";
-				}
-				return symbol.Text;
-			}
-			else
-			{
-				return symbol != null ? symbol.ToString() : "<null>";
-			}
-		}
+        public override string ToString()
+        {
+            if (symbol != null)
+            {
+                if (symbol.Type == IToken.Eof)
+                {
+                    return "<EOF>";
+                }
+                return symbol.Text;
+            }
+            else
+            {
+                return symbol != null ? symbol.ToString() : "<null>";
+            }
+        }
 
-		public virtual string ToStringTree()
-		{
-			return ToString();
-		}
-	}
+        public virtual string ToStringTree()
+        {
+            return ToString();
+        }
+    }
 }
diff --git a/Antlr4.Runtime/Tree/Trees.cs b/Antlr4.Runtime/Tree/Trees.cs
index 73166a88a..a29160cf2 100644
--- a/Antlr4.Runtime/Tree/Trees.cs
+++ b/Antlr4.Runtime/Tree/Trees.cs
@@ -38,174 +38,174 @@ using Sharpen;
 
 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
-	{
-		public static string GetPS(ITree t, IList<string> ruleNames, string fontName, int
-			 fontSize)
-		{
-			TreePostScriptGenerator psgen = new TreePostScriptGenerator(ruleNames, t, fontName
-				, fontSize);
-			return psgen.GetPS();
-		}
+    /// <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
+    {
+        public static string GetPS(ITree t, IList<string> ruleNames, string fontName, int
+             fontSize)
+        {
+            TreePostScriptGenerator psgen = new TreePostScriptGenerator(ruleNames, t, fontName
+                , fontSize);
+            return psgen.GetPS();
+        }
 
-		public static string GetPS(ITree t, IList<string> ruleNames)
-		{
-			return GetPS(t, ruleNames, "Helvetica", 11);
-		}
+        public static string GetPS(ITree t, IList<string> ruleNames)
+        {
+            return GetPS(t, ruleNames, "Helvetica", 11);
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public static void WritePS(ITree t, IList<string> ruleNames, string fileName, string
-			 fontName, int fontSize)
-		{
-			string ps = GetPS(t, ruleNames, fontName, fontSize);
-			FileWriter f = new FileWriter(fileName);
-			BufferedWriter bw = new BufferedWriter(f);
-			bw.Write(ps);
-			bw.Close();
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public static void WritePS(ITree t, IList<string> ruleNames, string fileName, string
+             fontName, int fontSize)
+        {
+            string ps = GetPS(t, ruleNames, fontName, fontSize);
+            FileWriter f = new FileWriter(fileName);
+            BufferedWriter bw = new BufferedWriter(f);
+            bw.Write(ps);
+            bw.Close();
+        }
 
-		/// <exception cref="System.IO.IOException"></exception>
-		public static void WritePS(ITree t, IList<string> ruleNames, string fileName)
-		{
-			WritePS(t, ruleNames, fileName, "Helvetica", 11);
-		}
+        /// <exception cref="System.IO.IOException"></exception>
+        public static void WritePS(ITree t, IList<string> ruleNames, string fileName)
+        {
+            WritePS(t, ruleNames, fileName, "Helvetica", 11);
+        }
 
-		/// <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)">GetNodeText(ITree, Antlr4.Runtime.Parser)
-		/// 	</see>
-		/// 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)">GetNodeText(ITree, Antlr4.Runtime.Parser)
+        ///     </see>
+        /// 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)">GetNodeText(ITree, Antlr4.Runtime.Parser)
-		/// 	</see>
-		/// 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.GetRuleNames() : 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)">GetNodeText(ITree, Antlr4.Runtime.Parser)
+        ///     </see>
+        /// 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.GetRuleNames() : 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)">GetNodeText(ITree, Antlr4.Runtime.Parser)
-		/// 	</see>
-		/// 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();
-		}
+        /// <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)">GetNodeText(ITree, Antlr4.Runtime.Parser)
+        ///     </see>
+        /// 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.GetRuleNames() : null;
-			IList<string> ruleNamesList = ruleNames != null ? Arrays.AsList(ruleNames) : null;
-			return GetNodeText(t, ruleNamesList);
-		}
+        public static string GetNodeText(ITree t, Parser recog)
+        {
+            string[] ruleNames = recog != null ? recog.GetRuleNames() : 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 IRuleNode)
-				{
-					int ruleIndex = ((IRuleNode)t).RuleContext.GetRuleIndex();
-					string ruleName = ruleNames[ruleIndex];
-					return ruleName;
-				}
-				else
-				{
-					if (t is IErrorNode)
-					{
-						return t.ToString();
-					}
-					else
-					{
-						if (t is ITerminalNode)
-						{
-							object symbol = ((ITerminalNode)t).Symbol;
-							if (symbol is IToken)
-							{
-								string s = ((IToken)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();
-		}
+        public static string GetNodeText(ITree t, IList<string> ruleNames)
+        {
+            if (ruleNames != null)
+            {
+                if (t is IRuleNode)
+                {
+                    int ruleIndex = ((IRuleNode)t).RuleContext.GetRuleIndex();
+                    string ruleName = ruleNames[ruleIndex];
+                    return ruleName;
+                }
+                else
+                {
+                    if (t is IErrorNode)
+                    {
+                        return t.ToString();
+                    }
+                    else
+                    {
+                        if (t is ITerminalNode)
+                        {
+                            object symbol = ((ITerminalNode)t).Symbol;
+                            if (symbol is IToken)
+                            {
+                                string s = ((IToken)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 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>
-		[NotNull]
-		public static IList<ITree> GetAncestors(ITree t)
-		{
-			if (t.Parent == null)
-			{
-				return Sharpen.Collections.EmptyList();
-			}
-			IList<ITree> ancestors = new List<ITree>();
-			t = t.Parent;
-			while (t != null)
-			{
-				ancestors.Add(0, t);
-				// insert at start
-				t = t.Parent;
-			}
-			return ancestors;
-		}
+        /// <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>
+        [NotNull]
+        public static IList<ITree> GetAncestors(ITree t)
+        {
+            if (t.Parent == null)
+            {
+                return Sharpen.Collections.EmptyList();
+            }
+            IList<ITree> ancestors = new List<ITree>();
+            t = t.Parent;
+            while (t != null)
+            {
+                ancestors.Add(0, t);
+                // insert at start
+                t = t.Parent;
+            }
+            return ancestors;
+        }
 
-		public Trees()
-		{
-		}
-	}
+        public Trees()
+        {
+        }
+    }
 }
diff --git a/Antlr4.Runtime/UnbufferedCharStream.cs b/Antlr4.Runtime/UnbufferedCharStream.cs
index 328a5131b..7a1fee239 100644
--- a/Antlr4.Runtime/UnbufferedCharStream.cs
+++ b/Antlr4.Runtime/UnbufferedCharStream.cs
@@ -35,413 +35,413 @@ using 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>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
-		/// <code>data.length</code>
-		/// .
-		/// </summary>
-		protected internal int n;
+        /// <summary>
+        /// The number of characters currently in
+        /// <see cref="data">data</see>
+        /// .
+        /// <p/>
+        /// This is not the buffer capacity, that's
+        /// <code>data.length</code>
+        /// .
+        /// </summary>
+        protected internal int n;
 
-		/// <summary>
-		/// 0..n-1 index into
-		/// <see cref="data">data</see>
-		/// of next character.
-		/// <p/>
-		/// The
-		/// <code>LA(1)</code>
-		/// character is
-		/// <code>data[p]</code>
-		/// . If
-		/// <code>p == n</code>
-		/// , we are
-		/// out of buffered characters.
-		/// </summary>
-		protected internal int p = 0;
+        /// <summary>
+        /// 0..n-1 index into
+        /// <see cref="data">data</see>
+        /// of next character.
+        /// <p/>
+        /// The
+        /// <code>LA(1)</code>
+        /// character is
+        /// <code>data[p]</code>
+        /// . If
+        /// <code>p == n</code>
+        /// , we are
+        /// out of buffered characters.
+        /// </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
-		/// <code>release()</code>
-		/// the last mark,
-		/// <code>numMarkers</code>
-		/// reaches 0 and we reset the buffer. Copy
-		/// <code>data[p]..data[n-1]</code>
-		/// to
-		/// <code>data[0]..data[(n-1)-p]</code>
-		/// .
-		/// </summary>
-		protected internal int numMarkers = 0;
+        /// <summary>
+        /// Count up with
+        /// <see cref="Mark()">mark()</see>
+        /// and down with
+        /// <see cref="Release(int)">release()</see>
+        /// . When we
+        /// <code>release()</code>
+        /// the last mark,
+        /// <code>numMarkers</code>
+        /// reaches 0 and we reset the buffer. Copy
+        /// <code>data[p]..data[n-1]</code>
+        /// to
+        /// <code>data[0]..data[(n-1)-p]</code>
+        /// .
+        /// </summary>
+        protected internal int numMarkers = 0;
 
-		/// <summary>
-		/// This is the
-		/// <code>LA(-1)</code>
-		/// character for the current position.
-		/// </summary>
-		protected internal int lastChar = -1;
+        /// <summary>
+        /// This is the
+        /// <code>LA(-1)</code>
+        /// character for the current position.
+        /// </summary>
+        protected internal int lastChar = -1;
 
-		/// <summary>
-		/// When
-		/// <code>numMarkers &gt; 0</code>
-		/// , this is the
-		/// <code>LA(-1)</code>
-		/// character for the
-		/// first character in
-		/// <see cref="data">data</see>
-		/// . Otherwise, this is unspecified.
-		/// </summary>
-		protected internal int lastCharBufferStart;
+        /// <summary>
+        /// When
+        /// <code>numMarkers &gt; 0</code>
+        /// , this is the
+        /// <code>LA(-1)</code>
+        /// 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
-		/// <code>LA(1)</code>
-		/// . 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;
+        /// <summary>Absolute character index.</summary>
+        /// <remarks>
+        /// Absolute character index. It's the index of the character about to be
+        /// read via
+        /// <code>LA(1)</code>
+        /// . 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 StreamReader input;
+        protected internal StreamReader 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>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() : 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];
-		}
+        /// <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(InputStream input) : this(input, 256)
-		{
-		}
+        public UnbufferedCharStream(InputStream input) : this(input, 256)
+        {
+        }
 
-		public UnbufferedCharStream(StreamReader input) : this(input, 256)
-		{
-		}
+        public UnbufferedCharStream(StreamReader input) : this(input, 256)
+        {
+        }
 
-		public UnbufferedCharStream(InputStream input, int bufferSize) : this(bufferSize)
-		{
-			this.input = new InputStreamReader(input);
-			Fill(1);
-		}
+        public UnbufferedCharStream(InputStream input, int bufferSize) : this(bufferSize)
+        {
+            this.input = new InputStreamReader(input);
+            Fill(1);
+        }
 
-		public UnbufferedCharStream(StreamReader input, int bufferSize) : this(bufferSize
-			)
-		{
-			// prime
-			this.input = input;
-			Fill(1);
-		}
+        public UnbufferedCharStream(StreamReader input, int bufferSize) : this(bufferSize
+            )
+        {
+            // prime
+            this.input = input;
+            Fill(1);
+        }
 
-		// prime
-		public virtual void Consume()
-		{
-			if (La(1) == IIntStream.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);
-		}
+        // prime
+        public virtual void Consume()
+        {
+            if (La(1) == IIntStream.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
-		/// <code>p</code>
-		/// index is
-		/// <code>data.length-1</code>
-		/// .
-		/// <code>p+need-1</code>
-		/// is
-		/// the char index 'need' elements ahead. If we need 1 element,
-		/// <code>(p+1-1)==p</code>
-		/// must be less than
-		/// <code>data.length</code>
-		/// .
-		/// </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>
+        /// Make sure we have 'need' elements from current position
+        /// <see cref="p">p</see>
+        /// .
+        /// Last valid
+        /// <code>p</code>
+        /// index is
+        /// <code>data.length-1</code>
+        /// .
+        /// <code>p+need-1</code>
+        /// is
+        /// the char index 'need' elements ahead. If we need 1 element,
+        /// <code>(p+1-1)==p</code>
+        /// must be less than
+        /// <code>data.length</code>
+        /// .
+        /// </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
-		/// <code>n</code>
-		/// characters to the buffer. Returns the number of characters
-		/// actually added to the buffer. If the return value is less than
-		/// <code>n</code>
-		/// ,
-		/// then EOF was reached before
-		/// <code>n</code>
-		/// 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] == IIntStream.Eof)
-				{
-					return i;
-				}
-				try
-				{
-					int c = NextChar();
-					Add(c);
-				}
-				catch (IOException ioe)
-				{
-					throw new RuntimeException(ioe);
-				}
-			}
-			return n;
-		}
+        /// <summary>
+        /// Add
+        /// <code>n</code>
+        /// characters to the buffer. Returns the number of characters
+        /// actually added to the buffer. If the return value is less than
+        /// <code>n</code>
+        /// ,
+        /// then EOF was reached before
+        /// <code>n</code>
+        /// 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] == IIntStream.Eof)
+                {
+                    return i;
+                }
+                try
+                {
+                    int c = NextChar();
+                    Add(c);
+                }
+                catch (IOException ioe)
+                {
+                    throw new RuntimeException(ioe);
+                }
+            }
+            return n;
+        }
 
-		/// <summary>
-		/// Override to provide different source of characters than
-		/// <see cref="input">input</see>
-		/// .
-		/// </summary>
-		/// <exception cref="System.IO.IOException"></exception>
-		protected internal virtual int NextChar()
-		{
-			return input.Read();
-		}
+        /// <summary>
+        /// Override to provide different source of characters than
+        /// <see cref="input">input</see>
+        /// .
+        /// </summary>
+        /// <exception cref="System.IO.IOException"></exception>
+        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;
-		}
+        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 IIntStream.Eof;
-			}
-			int c = data[index];
-			if (c == (char)IIntStream.Eof)
-			{
-				return IIntStream.Eof;
-			}
-			return 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 IIntStream.Eof;
+            }
+            int c = data[index];
+            if (c == (char)IIntStream.Eof)
+            {
+                return IIntStream.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
-		/// <code>seek()</code>
-		/// is called on a mark or
-		/// <code>release()</code>
-		/// is called in the wrong order.
-		/// </remarks>
-		public virtual int Mark()
-		{
-			if (numMarkers == 0)
-			{
-				lastCharBufferStart = lastChar;
-			}
-			int mark = -numMarkers - 1;
-			numMarkers++;
-			return mark;
-		}
+        /// <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
+        /// <code>seek()</code>
+        /// is called on a mark or
+        /// <code>release()</code>
+        /// is called in the wrong order.
+        /// </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"></param>
-		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;
-			}
-		}
+        /// <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"></param>
+        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;
-			}
-		}
+        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
-		/// <code>p</code>
-		/// to
-		/// <code>index-bufferStartIndex</code>
-		/// .
-		/// </remarks>
-		public virtual void Seek(int index)
-		{
-			if (index == currentCharIndex)
-			{
-				return;
-			}
-			if (index > currentCharIndex)
-			{
-				Sync(index - currentCharIndex);
-				index = Math.Min(index, GetBufferStartIndex() + n - 1);
-			}
-			// index == to bufferStartIndex should set p to 0
-			int i = index - GetBufferStartIndex();
-			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 "
-						 + GetBufferStartIndex() + ".." + (GetBufferStartIndex() + n));
-				}
-			}
-			p = i;
-			currentCharIndex = index;
-			if (p == 0)
-			{
-				lastChar = lastCharBufferStart;
-			}
-			else
-			{
-				lastChar = data[p - 1];
-			}
-		}
+        /// <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
+        /// <code>p</code>
+        /// to
+        /// <code>index-bufferStartIndex</code>
+        /// .
+        /// </remarks>
+        public virtual void Seek(int index)
+        {
+            if (index == currentCharIndex)
+            {
+                return;
+            }
+            if (index > currentCharIndex)
+            {
+                Sync(index - currentCharIndex);
+                index = Math.Min(index, GetBufferStartIndex() + n - 1);
+            }
+            // index == to bufferStartIndex should set p to 0
+            int i = index - GetBufferStartIndex();
+            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 "
+                         + GetBufferStartIndex() + ".." + (GetBufferStartIndex() + 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 int Size
+        {
+            get
+            {
+                throw new NotSupportedException("Unbuffered stream cannot know its size");
+            }
+        }
 
-		public virtual string SourceName
-		{
-			get
-			{
-				return name;
-			}
-		}
+        public virtual string SourceName
+        {
+            get
+            {
+                return name;
+            }
+        }
 
-		public override string GetText(Interval interval)
-		{
-			if (interval.a < 0 || interval.b < interval.a - 1)
-			{
-				throw new ArgumentException("invalid interval");
-			}
-			int bufferStartIndex = GetBufferStartIndex();
-			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));
-			}
-			// convert from absolute to local index
-			int i = interval.a - bufferStartIndex;
-			return new string(data, i, interval.Length());
-		}
+        public override string GetText(Interval interval)
+        {
+            if (interval.a < 0 || interval.b < interval.a - 1)
+            {
+                throw new ArgumentException("invalid interval");
+            }
+            int bufferStartIndex = GetBufferStartIndex();
+            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));
+            }
+            // convert from absolute to local index
+            int i = interval.a - bufferStartIndex;
+            return new string(data, i, interval.Length());
+        }
 
-		protected internal int GetBufferStartIndex()
-		{
-			return currentCharIndex - p;
-		}
-	}
+        protected internal int GetBufferStartIndex()
+        {
+            return currentCharIndex - p;
+        }
+    }
 }
diff --git a/Antlr4.Runtime/UnbufferedTokenStream.cs b/Antlr4.Runtime/UnbufferedTokenStream.cs
index 0363c27a4..c7da1c5e7 100644
--- a/Antlr4.Runtime/UnbufferedTokenStream.cs
+++ b/Antlr4.Runtime/UnbufferedTokenStream.cs
@@ -35,400 +35,400 @@ using Sharpen;
 
 namespace Antlr4.Runtime
 {
-	public class UnbufferedTokenStream : ITokenStream
-	{
-		protected internal ITokenSource tokenSource;
+    public class UnbufferedTokenStream : ITokenStream
+    {
+        protected internal 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>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
-		/// <code>tokens.length</code>
-		/// .
-		/// </summary>
-		protected internal int n;
+        /// <summary>
+        /// The number of tokens currently in
+        /// <see cref="tokens">tokens</see>
+        /// .
+        /// <p/>
+        /// This is not the buffer capacity, that's
+        /// <code>tokens.length</code>
+        /// .
+        /// </summary>
+        protected internal int n;
 
-		/// <summary>
-		/// 0..n-1 index into
-		/// <see cref="tokens">tokens</see>
-		/// of next token.
-		/// <p/>
-		/// The
-		/// <code>LT(1)</code>
-		/// token is
-		/// <code>tokens[p]</code>
-		/// . If
-		/// <code>p == n</code>
-		/// , we are
-		/// out of buffered tokens.
-		/// </summary>
-		protected internal int p = 0;
+        /// <summary>
+        /// 0..n-1 index into
+        /// <see cref="tokens">tokens</see>
+        /// of next token.
+        /// <p/>
+        /// The
+        /// <code>LT(1)</code>
+        /// token is
+        /// <code>tokens[p]</code>
+        /// . If
+        /// <code>p == n</code>
+        /// , we are
+        /// out of buffered tokens.
+        /// </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
-		/// <code>release()</code>
-		/// the last mark,
-		/// <code>numMarkers</code>
-		/// reaches 0 and we reset the buffer. Copy
-		/// <code>tokens[p]..tokens[n-1]</code>
-		/// to
-		/// <code>tokens[0]..tokens[(n-1)-p]</code>
-		/// .
-		/// </summary>
-		protected internal int numMarkers = 0;
+        /// <summary>
+        /// Count up with
+        /// <see cref="Mark()">mark()</see>
+        /// and down with
+        /// <see cref="Release(int)">release()</see>
+        /// . When we
+        /// <code>release()</code>
+        /// the last mark,
+        /// <code>numMarkers</code>
+        /// reaches 0 and we reset the buffer. Copy
+        /// <code>tokens[p]..tokens[n-1]</code>
+        /// to
+        /// <code>tokens[0]..tokens[(n-1)-p]</code>
+        /// .
+        /// </summary>
+        protected internal int numMarkers = 0;
 
-		/// <summary>
-		/// This is the
-		/// <code>LT(-1)</code>
-		/// token for the current position.
-		/// </summary>
-		protected internal IToken lastToken;
+        /// <summary>
+        /// This is the
+        /// <code>LT(-1)</code>
+        /// token for the current position.
+        /// </summary>
+        protected internal IToken lastToken;
 
-		/// <summary>
-		/// When
-		/// <code>numMarkers &gt; 0</code>
-		/// , this is the
-		/// <code>LT(-1)</code>
-		/// token for the
-		/// first token in
-		/// <see cref="tokens">tokens</see>
-		/// . Otherwise, this is
-		/// <code>null</code>
-		/// .
-		/// </summary>
-		protected internal IToken lastTokenBufferStart;
+        /// <summary>
+        /// When
+        /// <code>numMarkers &gt; 0</code>
+        /// , this is the
+        /// <code>LT(-1)</code>
+        /// token for the
+        /// first token in
+        /// <see cref="tokens">tokens</see>
+        /// . Otherwise, this is
+        /// <code>null</code>
+        /// .
+        /// </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
-		/// <code>LT(1)</code>
-		/// . 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">IWritableToken</see>
-		/// .
-		/// </remarks>
-		protected internal int currentTokenIndex = 0;
+        /// <summary>Absolute token index.</summary>
+        /// <remarks>
+        /// Absolute token index. It's the index of the token about to be read via
+        /// <code>LT(1)</code>
+        /// . 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">IWritableToken</see>
+        /// .
+        /// </remarks>
+        protected internal int currentTokenIndex = 0;
 
-		public UnbufferedTokenStream(ITokenSource tokenSource) : this(tokenSource, 256)
-		{
-		}
+        public UnbufferedTokenStream(ITokenSource tokenSource) : this(tokenSource, 256)
+        {
+        }
 
-		public UnbufferedTokenStream(ITokenSource tokenSource, int bufferSize)
-		{
-			this.tokenSource = tokenSource;
-			IToken[] tokens = new IToken[bufferSize];
-			this.tokens = tokens;
-			n = 0;
-			Fill(1);
-		}
+        public UnbufferedTokenStream(ITokenSource tokenSource, int bufferSize)
+        {
+            this.tokenSource = tokenSource;
+            IToken[] tokens = new IToken[bufferSize];
+            this.tokens = tokens;
+            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];
-		}
+        // 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 == IToken.Eof);
-				return tokens[n - 1];
-			}
-			return tokens[index];
-		}
+        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 == IToken.Eof);
+                return tokens[n - 1];
+            }
+            return tokens[index];
+        }
 
-		public virtual int La(int i)
-		{
-			return Lt(i).Type;
-		}
+        public virtual int La(int i)
+        {
+            return Lt(i).Type;
+        }
 
-		public virtual ITokenSource TokenSource
-		{
-			get
-			{
-				return tokenSource;
-			}
-		}
+        public virtual ITokenSource TokenSource
+        {
+            get
+            {
+                return tokenSource;
+            }
+        }
 
-		[NotNull]
-		public virtual string GetText()
-		{
-			return string.Empty;
-		}
+        [NotNull]
+        public virtual string GetText()
+        {
+            return string.Empty;
+        }
 
-		[NotNull]
-		public virtual string GetText(RuleContext ctx)
-		{
-			return GetText(ctx.SourceInterval);
-		}
+        [NotNull]
+        public virtual string GetText(RuleContext ctx)
+        {
+            return GetText(ctx.SourceInterval);
+        }
 
-		[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."
-				);
-		}
+        [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) == IToken.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);
-		}
+        public virtual void Consume()
+        {
+            if (La(1) == IToken.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
-		/// <code>p</code>
-		/// index is
-		/// <code>tokens.length-1</code>
-		/// .
-		/// <code>p+need-1</code>
-		/// is the tokens index 'need' elements
-		/// ahead.  If we need 1 element,
-		/// <code>(p+1-1)==p</code>
-		/// must be less than
-		/// <code>tokens.length</code>
-		/// .
-		/// </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>
+        /// Make sure we have 'need' elements from current position
+        /// <see cref="p">p</see>
+        /// . Last valid
+        /// <code>p</code>
+        /// index is
+        /// <code>tokens.length-1</code>
+        /// .
+        /// <code>p+need-1</code>
+        /// is the tokens index 'need' elements
+        /// ahead.  If we need 1 element,
+        /// <code>(p+1-1)==p</code>
+        /// must be less than
+        /// <code>tokens.length</code>
+        /// .
+        /// </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
-		/// <code>n</code>
-		/// elements to the buffer. Returns the number of tokens
-		/// actually added to the buffer. If the return value is less than
-		/// <code>n</code>
-		/// ,
-		/// then EOF was reached before
-		/// <code>n</code>
-		/// 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 == IToken.Eof)
-				{
-					return i;
-				}
-				IToken t = tokenSource.NextToken();
-				Add(t);
-			}
-			return n;
-		}
+        /// <summary>
+        /// Add
+        /// <code>n</code>
+        /// elements to the buffer. Returns the number of tokens
+        /// actually added to the buffer. If the return value is less than
+        /// <code>n</code>
+        /// ,
+        /// then EOF was reached before
+        /// <code>n</code>
+        /// 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 == IToken.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;
-		}
+        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
-		/// <code>seek()</code>
-		/// is called on a mark or
-		/// <code>release()</code>
-		/// is called in the wrong order.
-		/// </remarks>
-		public virtual int Mark()
-		{
-			if (numMarkers == 0)
-			{
-				lastTokenBufferStart = lastToken;
-			}
-			int mark = -numMarkers - 1;
-			numMarkers++;
-			return mark;
-		}
+        /// <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
+        /// <code>seek()</code>
+        /// is called on a mark or
+        /// <code>release()</code>
+        /// is called in the wrong order.
+        /// </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 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 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 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 int Size
+        {
+            get
+            {
+                throw new NotSupportedException("Unbuffered stream cannot know its size");
+            }
+        }
 
-		public virtual string SourceName
-		{
-			get
-			{
-				return tokenSource.SourceName;
-			}
-		}
+        public virtual string SourceName
+        {
+            get
+            {
+                return tokenSource.SourceName;
+            }
+        }
 
-		[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();
-		}
+        [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;
-		}
-	}
+        protected internal int GetBufferStartIndex()
+        {
+            return currentTokenIndex - p;
+        }
+    }
 }
diff --git a/reference/sharpen b/reference/sharpen
index 8aa52c8df..f14a6feae 160000
--- a/reference/sharpen
+++ b/reference/sharpen
@@ -1 +1 @@
-Subproject commit 8aa52c8df7ecc4daf6331ae4ef75320bff24ceeb
+Subproject commit f14a6feaed23300e61e95b09756cd2295c1e2636
diff --git a/reference/sharpen-all-options.txt b/reference/sharpen-all-options.txt
index 9f7e7ff03..e5ec4a755 100644
--- a/reference/sharpen-all-options.txt
+++ b/reference/sharpen-all-options.txt
@@ -2,6 +2,7 @@
 -nativeTypeSystem 
 -organizeUsings
 -nativeInterfaces
+-tabToSpaces
 
 -methodMapping System.out.println System.Console.WriteLine
 

From 9735d882745b284ef3aa06de9b8a00c34c713b06 Mon Sep 17 00:00:00 2001
From: Sam Harwell <sam@tunnelvisionlabs.com>
Date: Sat, 16 Feb 2013 08:20:55 -0600
Subject: [PATCH 10/10] Ignore files generated by the sharpen process

---
 .gitignore       | 2 ++
 reference/antlr4 | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 1426b2970..9bb2bf3ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,5 @@
 # ignore C# build directories
 [Dd]ebug/
 [Rr]elease/
+reference/.metadata/
+reference/antlr4.net/
diff --git a/reference/antlr4 b/reference/antlr4
index 88652241c..878b34fec 160000
--- a/reference/antlr4
+++ b/reference/antlr4
@@ -1 +1 @@
-Subproject commit 88652241cf2c248a66307e5866be98e3910b6519
+Subproject commit 878b34fecc519d3eb131fa5f83db6a6a70face61