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);
+	}
+}