diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000..f6f13e6c96
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+################################################################################
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+################################################################################
+
+.vs/
+/**/obj/**
+/**/bin/**
\ No newline at end of file
diff --git a/docs/architecture.md b/docs/0_architecture.md
similarity index 99%
rename from docs/architecture.md
rename to docs/0_architecture.md
index 17afb7c4f8..ee5a819326 100644
--- a/docs/architecture.md
+++ b/docs/0_architecture.md
@@ -486,61 +486,3 @@ Clearly, there's still a lot of infrastructure to flesh out, and a lot of implem
 4. handling serialization of customer-defined types
 5. CSDL defined authz
 6. custom headers, query options, endpoints, etc.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/docs/1_interfaces+datatypes.md b/docs/1_interfaces+datatypes.md
new file mode 100644
index 0000000000..a9bb20bbd4
--- /dev/null
+++ b/docs/1_interfaces+datatypes.md
@@ -0,0 +1,70 @@
+## pattern overview
+
+We should stick to the naming conventions laid out in the [architecture](./architecture.md). So, we should have "parser"s to create CSTs from strings, "converter"s to move between CSTs and ASTs, "translator"s to move between different types of ASTs, "transcriber"s to create strings from CSTs, "serializer"s to go from user defined types to ASTs, and "deserializer"s to go from ASTs to user defined types. 
+
+The CSTs will be a discriminated union that corresponds directly to the [OData ABNF](https://docs.oasis-open.org/odata/odata/v4.01/cs01/abnf/odata-abnf-construction-rules.txt).
+
+The ASTs will be a discriminated union that corresponds to the same ABNF but with the string literals removed, as well as "overhead" from the CST like aliases. 
+
+The transcribers will be implemented as visitors on the CST nodes to convert them to strings using an intermediate `StringBuilder`.
+
+The converters will be implemented as visitors on the AST or CST nodes to produce instances of the other.
+
+TODO parsers will be...
+
+The translators will be implemented as visitors on the AST nodes to produce a corresponding AST for the desired data store.
+
+Please see the [appendix](#appendix) for other modeling options that were explored.
+
+## odata resource path example
+
+Let's use the odata resource path as an example of the above patterns.
+
+### syntactic CST?
+
+TODO do you want to have a syntactic CST that is a context-free grammar (should the context free grammar be defined by the literals used in the ABNF? write this out and keep it somewhere if so)? then your parsers could be combinators; if you do this you will need a converter from syntactic to semantic CST
+TODO regardless of the above, you need to have a syntactic CST **anyway** to have parity with ODL
+
+### (semantic?) CST
+
+A sample implementation of the CST is [here](../odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/OdataRelativeUri.cs).
+
+### AST
+
+A sample implementation of the AST is [here](../odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/OdataRelativeUri.cs).
+
+### CST transcriber
+
+A sample implementation of the transcriber is [here](../odata/Root/OdataResourcePath/Transcribers/OdataRelativeUriTranscriber.cs).
+
+### CST to AST converter
+
+A sample implementation of the CST to AST translator is [here](../odata/Root/OdataResourcePath/CstToAstTranslators/OdataRelativeUriTranslator.cs).
+
+### AST to CST converter
+
+A sample implementation of the CST to AST translator is [here](../odata/Root/OdataResourcePath/AstToCstTranslators/OdataRelativeUriTranslator.cs).
+
+### uri parser
+
+TODO
+
+### translator
+
+TODO
+
+## let's now attempt take some time to show mechanically how to implement a node in the AST and all of its associated utilities
+
+Let's try with `keyPredicate` using the [ABNF](https://docs.oasis-open.org/odata/odata/v4.01/cs01/abnf/odata-abnf-construction-rules.txt).
+
+## some takeaways
+
+Using this discriminated union pattern, it is clear from the code where the "feature gaps" are: any nodes that only have a private constructor have not yet been implemented. We should implement a node in its completeness so that we can maintain this status. Doing this will ensure that the "feature gaps" are never tribal knowledge, but something that any developer can discover just by looking at the code.
+
+These unions *also* allow us to easily scale across developers. Any number of developers can implement as many nodes as there are developers provided that no two developers are working on the same node. Also, by separating each phase of the handling process in this way, we are able to implement the nodes "piecewise", meaning: a developer can define the AST node, create a PR, and merge it; the developer can then define the CST node, create a PR, and merge it; they can then implement a converter, and so in. These can all be done as individual, discrete, atomic steps done (mostly) independently of each other. 
+
+## appendix
+
+### parsing
+
+Parser combinators were tried using the Sprache nuget package. Though combinators are very flexible, the code is trivially readable, and development is exceedingly fast, combinators result in potentially incorrect parsing on grammars that are not context-free; the OData ABNF is not a context-free grammar, so we cannot rely on combinators. You can see an attempt at this implementation [here](https://github.com/OData/odata.net/blob/corranrogue9/framework/interfacesanddatatypes/odata/Root/OdataResourcePath/CombinatorParsers/OdataRelativeUriParser.cs).
diff --git a/odata.sln b/odata.sln
new file mode 100644
index 0000000000..87252d662f
--- /dev/null
+++ b/odata.sln
@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.12.35514.174
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "odata", "odata\odata.csproj", "{6E3F11CA-8949-47C1-894C-CE61D911A2F2}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "odata.tests", "odata.tests\odata.tests.csproj", "{07CA58E0-3FA7-4BC2-8CB1-6974049CB5CF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{6E3F11CA-8949-47C1-894C-CE61D911A2F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6E3F11CA-8949-47C1-894C-CE61D911A2F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6E3F11CA-8949-47C1-894C-CE61D911A2F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6E3F11CA-8949-47C1-894C-CE61D911A2F2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{07CA58E0-3FA7-4BC2-8CB1-6974049CB5CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{07CA58E0-3FA7-4BC2-8CB1-6974049CB5CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{07CA58E0-3FA7-4BC2-8CB1-6974049CB5CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{07CA58E0-3FA7-4BC2-8CB1-6974049CB5CF}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/odata.tests/MSTestSettings.cs b/odata.tests/MSTestSettings.cs
new file mode 100644
index 0000000000..aaf278c844
--- /dev/null
+++ b/odata.tests/MSTestSettings.cs
@@ -0,0 +1 @@
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]
diff --git a/odata.tests/Test1.cs b/odata.tests/Test1.cs
new file mode 100644
index 0000000000..3a40f86b93
--- /dev/null
+++ b/odata.tests/Test1.cs
@@ -0,0 +1,226 @@
+namespace odata.tests
+{
+    using AbnfParser.CstNodes.Core;
+    using Root;
+    using Root.OdataResourcePath.CombinatorParsers;
+    using Root.OdataResourcePath.Transcribers;
+    using Sprache;
+    using System.Text;
+
+    [TestClass]
+    public sealed class Test1
+    {
+        [TestMethod]
+        public void TestMethod1()
+        {
+            var url = "$metadata";
+            var cst = OdataRelativeUriParser.Instance.Parse(url);
+
+            var ast = Root.OdataResourcePath.CstToAstConverters.OdataRelativeUriConverter
+                .Default
+                .Visit(cst, default);
+
+            var newCst = Root.OdataResourcePath.AstToCstConverters.OdataRelativeUriConverter
+                .Default
+                .Visit(ast, default);
+
+            var stringBuilder = new StringBuilder();
+            OdataRelativeUriTranscriber.Default.Visit(newCst, stringBuilder);
+
+            Assert.AreEqual(url, stringBuilder.ToString());
+        }
+
+        [TestMethod]
+        public void GenerateAlphaTranscribers()
+        {
+            var range = (0x01, 0x7E);
+
+            var builder = new StringBuilder();
+            for (int i = range.Item1; i <= range.Item2; ++i)
+            {
+                var className = $"x{i:X2}";
+                builder.AppendLine($"public sealed class {className}Transcriber");
+                builder.AppendLine("{");
+                builder.AppendLine($"private {className}Transcriber()");
+                builder.AppendLine("{");
+                builder.AppendLine("}");
+                builder.AppendLine();
+                builder.AppendLine($"public static {className}Transcriber Instance {{ get; }} = new {className}Transcriber();");
+                builder.AppendLine();
+                builder.AppendLine($"public Void Transcribe({className} node, StringBuilder context)");
+                builder.AppendLine("{");
+                builder.AppendLine($"context.Append((char)0{className});");
+                builder.AppendLine("return default;");
+                builder.AppendLine("}");
+                builder.AppendLine("}");
+            }
+
+            File.WriteAllText(@"C:\Users\gdebruin\code.txt", builder.ToString());
+        }
+
+        [TestMethod]
+        public void GenerateTranscriber()
+        {
+            var ranges = new[]
+            {
+                (0x20, 0x3D),
+                (0x3F, 0x7E),
+            };
+            var elementName = "ProseVal";
+
+            var builder = new StringBuilder();
+            builder.AppendLine("using System.Text;");
+            builder.AppendLine();
+            builder.AppendLine("using AbnfParser.CstNodes.Core;");
+            builder.AppendLine("using Root;");
+            builder.AppendLine();
+            builder.AppendLine($"public sealed class {elementName}Transcriber : {elementName}.Visitor<Void, StringBuilder>");
+            builder.AppendLine("{");
+            builder.AppendLine($"private {elementName}Transcriber()");
+            builder.AppendLine("{");
+            builder.AppendLine("}");
+            builder.AppendLine();
+            builder.AppendLine($"public static {elementName}Transcriber Instance {{ get; }} = new {elementName}Transcriber();");
+            builder.AppendLine();
+            foreach (var range in ranges)
+            {
+                GenerateAccepts(builder, elementName, range.Item1, range.Item2);
+            }
+
+            builder.AppendLine("}");
+
+            File.WriteAllText(@"C:\Users\gdebruin\code.txt", builder.ToString());
+        }
+
+        private void GenerateAccepts(StringBuilder builder, string elementName, int start, int end)
+        {
+            for (int i = start; i <= end; ++i)
+            {
+                var className = $"x{i:X2}";
+                builder.AppendLine($"protected internal override Void Accept({elementName}.{className} node, StringBuilder context)");
+                builder.AppendLine("{");
+                builder.AppendLine($"return {className}Transcriber.Instance.Transcribe(node.Value, context);");
+                builder.AppendLine("}");
+                builder.AppendLine();
+            }
+        }
+
+        [TestMethod]
+        public void Generate()
+        {
+            var ranges = new[]
+            {
+                (0x41, 0x5A),
+                (0x61, 0x7A),
+            };
+            var elementName = "ProseVal";
+
+            var builder = new StringBuilder();
+            builder.AppendLine("public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);");
+            builder.AppendLine();
+            builder.AppendLine("public abstract class Visitor<TResult, TContext>");
+            builder.AppendLine("{");
+            builder.AppendLine($"public TResult Visit({elementName} node, TContext context)");
+            builder.AppendLine("{");
+            builder.AppendLine("return node.Dispatch(this, context);");
+            builder.AppendLine("}");
+            builder.AppendLine();
+            foreach (var range in ranges)
+            {
+                GenerateAccepts(builder, range.Item1, range.Item2);
+            }
+
+            builder.AppendLine("}");
+            builder.AppendLine();
+            foreach (var range in ranges)
+            {
+                GenerateClasses(builder, elementName, range.Item1, range.Item2);
+            }
+
+
+            File.WriteAllText(@"C:\Users\gdebruin\code.txt", builder.ToString());
+        }
+
+        private void GenerateAccepts(StringBuilder builder, int start, int end)
+        {
+            for (int i = start; i <= end; ++i)
+            {
+                var className = $"x{i:X2}";
+                builder.AppendLine($"protected internal abstract TResult Accept({className} node, TContext context);");
+            }
+        }
+
+        private void GenerateClasses(StringBuilder builder, string elementName, int start, int end)
+        {
+            for (int i = start; i <= end; ++i)
+            {
+                var className = $"x{i:X2}";
+                builder.AppendLine($"public sealed class {className} : {elementName}");
+                builder.AppendLine("{");
+                builder.AppendLine($"public {className}(Core.x3C lessThan, Core.{className} value, Core.x3E greaterThan)");
+                builder.AppendLine("{");
+                builder.AppendLine("LessThan = lessThan;");
+                builder.AppendLine("Value = value;");
+                builder.AppendLine("GreaterThan = greaterThan;");
+                builder.AppendLine("}");
+                builder.AppendLine();
+                builder.AppendLine($"public Core.x3C LessThan {{ get; }}");
+                builder.AppendLine($"public Core.{className} Value {{ get; }}");
+                builder.AppendLine($"public Core.x3E GreaterThan {{ get; }}");
+                builder.AppendLine();
+                builder.AppendLine($"public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)");
+                builder.AppendLine("{");
+                builder.AppendLine("return visitor.Accept(this, context);");
+                builder.AppendLine("}");
+                builder.AppendLine("}");
+                builder.AppendLine();
+            }
+        }
+
+        [TestMethod]
+        public void CoreRules()
+        {
+            var coreRulesPath = @"C:\github\odata.net\odata\AbnfParser\core.abnf";
+            var coreRulesText = File.ReadAllText(coreRulesPath);
+            var cst = AbnfParser.CombinatorParsers.RuleListParser.Instance.Parse(coreRulesText);
+
+            //// TODO if the ABNF is missing a trailing newline, the last rule will be dropped
+
+            var stringBuilder = new StringBuilder();
+            AbnfParser.Transcribers.RuleListTranscriber.Instance.Transcribe(cst, stringBuilder);
+            var transcribedText = stringBuilder.ToString();
+            Assert.AreEqual(coreRulesText, transcribedText);
+        }
+
+        [TestMethod]
+        public void AbnfRules()
+        {
+            var coreRulesPath = @"C:\github\odata.net\odata\AbnfParser\core.abnf";
+            var coreRulesText = File.ReadAllText(coreRulesPath);
+            var abnfRulesPath = @"C:\github\odata.net\odata\AbnfParser\abnf.abnf";
+            var abnfRulesText = File.ReadAllText(abnfRulesPath);
+            var fullRulesText = string.Join(Environment.NewLine, abnfRulesText, coreRulesText);
+            var cst = AbnfParser.CombinatorParsers.RuleListParser.Instance.Parse(fullRulesText);
+
+            var stringBuilder = new StringBuilder();
+            AbnfParser.Transcribers.RuleListTranscriber.Instance.Transcribe(cst, stringBuilder);
+            var transcribedText = stringBuilder.ToString();
+            Assert.AreEqual(fullRulesText, transcribedText);
+        }
+
+        [TestMethod]
+        public void OdataRules()
+        {
+            var odataRulesPath = @"C:\github\odata.net\odata\odata.abnf";
+            var odataRulesText = File.ReadAllText(odataRulesPath);
+            var cst = AbnfParser.CombinatorParsers.RuleListParser.Instance.Parse(odataRulesText);
+
+            var stringBuilder = new StringBuilder();
+            AbnfParser.Transcribers.RuleListTranscriber.Instance.Transcribe(cst, stringBuilder);
+            var transcribedText = stringBuilder.ToString();
+
+            File.WriteAllText(odataRulesPath, transcribedText);
+            Assert.AreEqual(odataRulesText, transcribedText);
+        }
+    }
+}
diff --git a/odata.tests/odata.tests.csproj b/odata.tests/odata.tests.csproj
new file mode 100644
index 0000000000..abc9457433
--- /dev/null
+++ b/odata.tests/odata.tests.csproj
@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="MSTest" Version="3.6.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\odata\odata.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+  </ItemGroup>
+
+</Project>
diff --git a/odata/AbnfParser/CombinatorParsers/AlternationParser.cs b/odata/AbnfParser/CombinatorParsers/AlternationParser.cs
new file mode 100644
index 0000000000..0964dd3bb2
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/AlternationParser.cs
@@ -0,0 +1,24 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class AlternationParser
+    {
+        public static Parser<Alternation> Instance { get; } =
+            from concatenation in ConcatenationParser.Instance
+            from inners in InnerParser.Instance.Many()
+            select new Alternation(concatenation, inners);
+
+        public static class InnerParser
+        {
+            public static Parser<Alternation.Inner> Instance { get; } =
+                from prefixCwsps in CwspParser.Instance.Many()
+                from slash in x2FParser.Instance
+                from suffixCwsps in CwspParser.Instance.Many()
+                from concatenation in ConcatenationParser.Instance
+                select new Alternation.Inner(prefixCwsps, slash, suffixCwsps, concatenation);
+        }
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/BinValParser.cs b/odata/AbnfParser/CombinatorParsers/BinValParser.cs
new file mode 100644
index 0000000000..3575cce6d2
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/BinValParser.cs
@@ -0,0 +1,57 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class BinValParser
+    {
+        public static Parser<BinVal.BitsOnly> BitsOnly { get; } =
+            from b in x62Parser.Instance
+            from bits in BitParser.Instance.AtLeastOnce()
+            select new BinVal.BitsOnly(b, bits);
+
+        public static Parser<BinVal.ConcatenatedBits> ConcatenatedBits { get; } = ConcatenatedBitsParser.Instance;
+
+        public static class ConcatenatedBitsParser
+        {
+            public static Parser<BinVal.ConcatenatedBits> Instance { get; } =
+                from b in x62Parser.Instance
+                from bits in BitParser.Instance.AtLeastOnce()
+                from inners in InnerParser.Instance.AtLeastOnce()
+                select new BinVal.ConcatenatedBits(b, bits, inners);
+
+            public static class InnerParser
+            {
+                public static Parser<BinVal.ConcatenatedBits.Inner> Instance { get; } =
+                    from dot in x2EParser.Instance
+                    from bits in BitParser.Instance.AtLeastOnce()
+                    select new BinVal.ConcatenatedBits.Inner(dot, bits);
+            }
+        }
+
+        public static Parser<BinVal.Range> Range { get; } = RangeParser.Instance;
+
+        public static class RangeParser
+        {
+            public static Parser<BinVal.Range> Instance { get; } =
+                from b in x62Parser.Instance
+                from bits in BitParser.Instance.AtLeastOnce()
+                from inners in InnerParser.Instance.AtLeastOnce()
+                select new BinVal.Range(b, bits, inners);
+
+            public static class InnerParser
+            {
+                public static Parser<BinVal.Range.Inner> Instance { get; } =
+                    from dash in x2DParser.Instance
+                    from bits in BitParser.Instance.AtLeastOnce()
+                    select new BinVal.Range.Inner(dash, bits);
+            }
+        }
+
+        public static Parser<BinVal> Instance { get; } =
+            BitsOnly
+            .Or<BinVal>(ConcatenatedBits)
+            .Or(Range);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/CharValParser.cs b/odata/AbnfParser/CombinatorParsers/CharValParser.cs
new file mode 100644
index 0000000000..6f25f93442
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/CharValParser.cs
@@ -0,0 +1,490 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class CharValParser
+    {
+        public static Parser<CharVal> Instance { get; } =
+            from openDquote in DquoteParser.Instance
+            from inners in InnerParser.Instance.Many()
+            from closeDquote in DquoteParser.Instance
+            select new CharVal(openDquote, inners, closeDquote);
+
+        public static class InnerParser
+        {
+            public static Parser<CharVal.Inner.x20> x20 { get; } =
+                from value in x20Parser.Instance
+                select new CharVal.Inner.x20(value);
+
+            public static Parser<CharVal.Inner.x21> x21 { get; } =
+                from value in x21Parser.Instance
+                select new CharVal.Inner.x21(value);
+
+            public static Parser<CharVal.Inner.x23> x23 { get; } =
+                from value in x23Parser.Instance
+                select new CharVal.Inner.x23(value);
+
+            public static Parser<CharVal.Inner.x24> x24 { get; } =
+                from value in x24Parser.Instance
+                select new CharVal.Inner.x24(value);
+
+            public static Parser<CharVal.Inner.x25> x25 { get; } =
+                from value in x25Parser.Instance
+                select new CharVal.Inner.x25(value);
+
+            public static Parser<CharVal.Inner.x26> x26 { get; } =
+                from value in x26Parser.Instance
+                select new CharVal.Inner.x26(value);
+
+            public static Parser<CharVal.Inner.x27> x27 { get; } =
+                from value in x27Parser.Instance
+                select new CharVal.Inner.x27(value);
+
+            public static Parser<CharVal.Inner.x28> x28 { get; } =
+                from value in x28Parser.Instance
+                select new CharVal.Inner.x28(value);
+
+            public static Parser<CharVal.Inner.x29> x29 { get; } =
+                from value in x29Parser.Instance
+                select new CharVal.Inner.x29(value);
+
+            public static Parser<CharVal.Inner.x2A> x2A { get; } =
+                from value in x2AParser.Instance
+                select new CharVal.Inner.x2A(value);
+
+            public static Parser<CharVal.Inner.x2B> x2B { get; } =
+                from value in x2BParser.Instance
+                select new CharVal.Inner.x2B(value);
+
+            public static Parser<CharVal.Inner.x2C> x2C { get; } =
+                from value in x2CParser.Instance
+                select new CharVal.Inner.x2C(value);
+
+            public static Parser<CharVal.Inner.x2D> x2D { get; } =
+                from value in x2DParser.Instance
+                select new CharVal.Inner.x2D(value);
+
+            public static Parser<CharVal.Inner.x2E> x2E { get; } =
+                from value in x2EParser.Instance
+                select new CharVal.Inner.x2E(value);
+
+            public static Parser<CharVal.Inner.x2F> x2F { get; } =
+                from value in x2FParser.Instance
+                select new CharVal.Inner.x2F(value);
+
+            public static Parser<CharVal.Inner.x30> x30 { get; } =
+                from value in x30Parser.Instance
+                select new CharVal.Inner.x30(value);
+
+            public static Parser<CharVal.Inner.x31> x31 { get; } =
+                from value in x31Parser.Instance
+                select new CharVal.Inner.x31(value);
+
+            public static Parser<CharVal.Inner.x32> x32 { get; } =
+                from value in x32Parser.Instance
+                select new CharVal.Inner.x32(value);
+
+            public static Parser<CharVal.Inner.x33> x33 { get; } =
+                from value in x33Parser.Instance
+                select new CharVal.Inner.x33(value);
+
+            public static Parser<CharVal.Inner.x34> x34 { get; } =
+                from value in x34Parser.Instance
+                select new CharVal.Inner.x34(value);
+
+            public static Parser<CharVal.Inner.x35> x35 { get; } =
+                from value in x35Parser.Instance
+                select new CharVal.Inner.x35(value);
+
+            public static Parser<CharVal.Inner.x36> x36 { get; } =
+                from value in x36Parser.Instance
+                select new CharVal.Inner.x36(value);
+
+            public static Parser<CharVal.Inner.x37> x37 { get; } =
+                from value in x37Parser.Instance
+                select new CharVal.Inner.x37(value);
+
+            public static Parser<CharVal.Inner.x38> x38 { get; } =
+                from value in x38Parser.Instance
+                select new CharVal.Inner.x38(value);
+
+            public static Parser<CharVal.Inner.x39> x39 { get; } =
+                from value in x39Parser.Instance
+                select new CharVal.Inner.x39(value);
+
+            public static Parser<CharVal.Inner.x3A> x3A { get; } =
+                from value in x3AParser.Instance
+                select new CharVal.Inner.x3A(value);
+
+            public static Parser<CharVal.Inner.x3B> x3B { get; } =
+                from value in x3BParser.Instance
+                select new CharVal.Inner.x3B(value);
+
+            public static Parser<CharVal.Inner.x3C> x3C { get; } =
+                from value in x3CParser.Instance
+                select new CharVal.Inner.x3C(value);
+
+            public static Parser<CharVal.Inner.x3D> x3D { get; } =
+                from value in x3DParser.Instance
+                select new CharVal.Inner.x3D(value);
+
+            public static Parser<CharVal.Inner.x3E> x3E { get; } =
+                from value in x3EParser.Instance
+                select new CharVal.Inner.x3E(value);
+
+            public static Parser<CharVal.Inner.x3F> x3F { get; } =
+                from value in x3FParser.Instance
+                select new CharVal.Inner.x3F(value);
+
+            public static Parser<CharVal.Inner.x40> x40 { get; } =
+                from value in x40Parser.Instance
+                select new CharVal.Inner.x40(value);
+
+            public static Parser<CharVal.Inner.x41> x41 { get; } =
+                from value in x41Parser.Instance
+                select new CharVal.Inner.x41(value);
+
+            public static Parser<CharVal.Inner.x42> x42 { get; } =
+                from value in x42Parser.Instance
+                select new CharVal.Inner.x42(value);
+
+            public static Parser<CharVal.Inner.x43> x43 { get; } =
+                from value in x43Parser.Instance
+                select new CharVal.Inner.x43(value);
+
+            public static Parser<CharVal.Inner.x44> x44 { get; } =
+                from value in x44Parser.Instance
+                select new CharVal.Inner.x44(value);
+
+            public static Parser<CharVal.Inner.x45> x45 { get; } =
+                from value in x45Parser.Instance
+                select new CharVal.Inner.x45(value);
+
+            public static Parser<CharVal.Inner.x46> x46 { get; } =
+                from value in x46Parser.Instance
+                select new CharVal.Inner.x46(value);
+
+            public static Parser<CharVal.Inner.x47> x47 { get; } =
+                from value in x47Parser.Instance
+                select new CharVal.Inner.x47(value);
+
+            public static Parser<CharVal.Inner.x48> x48 { get; } =
+                from value in x48Parser.Instance
+                select new CharVal.Inner.x48(value);
+
+            public static Parser<CharVal.Inner.x49> x49 { get; } =
+                from value in x49Parser.Instance
+                select new CharVal.Inner.x49(value);
+
+            public static Parser<CharVal.Inner.x4A> x4A { get; } =
+                from value in x4AParser.Instance
+                select new CharVal.Inner.x4A(value);
+
+            public static Parser<CharVal.Inner.x4B> x4B { get; } =
+                from value in x4BParser.Instance
+                select new CharVal.Inner.x4B(value);
+
+            public static Parser<CharVal.Inner.x4C> x4C { get; } =
+                from value in x4CParser.Instance
+                select new CharVal.Inner.x4C(value);
+
+            public static Parser<CharVal.Inner.x4D> x4D { get; } =
+                from value in x4DParser.Instance
+                select new CharVal.Inner.x4D(value);
+
+            public static Parser<CharVal.Inner.x4E> x4E { get; } =
+                from value in x4EParser.Instance
+                select new CharVal.Inner.x4E(value);
+
+            public static Parser<CharVal.Inner.x4F> x4F { get; } =
+                from value in x4FParser.Instance
+                select new CharVal.Inner.x4F(value);
+
+            public static Parser<CharVal.Inner.x50> x50 { get; } =
+                from value in x50Parser.Instance
+                select new CharVal.Inner.x50(value);
+
+            public static Parser<CharVal.Inner.x51> x51 { get; } =
+                from value in x51Parser.Instance
+                select new CharVal.Inner.x51(value);
+
+            public static Parser<CharVal.Inner.x52> x52 { get; } =
+                from value in x52Parser.Instance
+                select new CharVal.Inner.x52(value);
+
+            public static Parser<CharVal.Inner.x53> x53 { get; } =
+                from value in x53Parser.Instance
+                select new CharVal.Inner.x53(value);
+
+            public static Parser<CharVal.Inner.x54> x54 { get; } =
+                from value in x54Parser.Instance
+                select new CharVal.Inner.x54(value);
+
+            public static Parser<CharVal.Inner.x55> x55 { get; } =
+                from value in x55Parser.Instance
+                select new CharVal.Inner.x55(value);
+
+            public static Parser<CharVal.Inner.x56> x56 { get; } =
+                from value in x56Parser.Instance
+                select new CharVal.Inner.x56(value);
+
+            public static Parser<CharVal.Inner.x57> x57 { get; } =
+                from value in x57Parser.Instance
+                select new CharVal.Inner.x57(value);
+
+            public static Parser<CharVal.Inner.x58> x58 { get; } =
+                from value in x58Parser.Instance
+                select new CharVal.Inner.x58(value);
+
+            public static Parser<CharVal.Inner.x59> x59 { get; } =
+                from value in x59Parser.Instance
+                select new CharVal.Inner.x59(value);
+
+            public static Parser<CharVal.Inner.x5A> x5A { get; } =
+                from value in x5AParser.Instance
+                select new CharVal.Inner.x5A(value);
+
+            public static Parser<CharVal.Inner.x5B> x5B { get; } =
+                from value in x5BParser.Instance
+                select new CharVal.Inner.x5B(value);
+
+            public static Parser<CharVal.Inner.x5C> x5C { get; } =
+                from value in x5CParser.Instance
+                select new CharVal.Inner.x5C(value);
+
+            public static Parser<CharVal.Inner.x5D> x5D { get; } =
+                from value in x5DParser.Instance
+                select new CharVal.Inner.x5D(value);
+
+            public static Parser<CharVal.Inner.x5E> x5E { get; } =
+                from value in x5EParser.Instance
+                select new CharVal.Inner.x5E(value);
+
+            public static Parser<CharVal.Inner.x5F> x5F { get; } =
+                from value in x5FParser.Instance
+                select new CharVal.Inner.x5F(value);
+
+            public static Parser<CharVal.Inner.x60> x60 { get; } =
+                from value in x60Parser.Instance
+                select new CharVal.Inner.x60(value);
+
+            public static Parser<CharVal.Inner.x61> x61 { get; } =
+                from value in x61Parser.Instance
+                select new CharVal.Inner.x61(value);
+
+            public static Parser<CharVal.Inner.x62> x62 { get; } =
+                from value in x62Parser.Instance
+                select new CharVal.Inner.x62(value);
+
+            public static Parser<CharVal.Inner.x63> x63 { get; } =
+                from value in x63Parser.Instance
+                select new CharVal.Inner.x63(value);
+
+            public static Parser<CharVal.Inner.x64> x64 { get; } =
+                from value in x64Parser.Instance
+                select new CharVal.Inner.x64(value);
+
+            public static Parser<CharVal.Inner.x65> x65 { get; } =
+                from value in x65Parser.Instance
+                select new CharVal.Inner.x65(value);
+
+            public static Parser<CharVal.Inner.x66> x66 { get; } =
+                from value in x66Parser.Instance
+                select new CharVal.Inner.x66(value);
+
+            public static Parser<CharVal.Inner.x67> x67 { get; } =
+                from value in x67Parser.Instance
+                select new CharVal.Inner.x67(value);
+
+            public static Parser<CharVal.Inner.x68> x68 { get; } =
+                from value in x68Parser.Instance
+                select new CharVal.Inner.x68(value);
+
+            public static Parser<CharVal.Inner.x69> x69 { get; } =
+                from value in x69Parser.Instance
+                select new CharVal.Inner.x69(value);
+
+            public static Parser<CharVal.Inner.x6A> x6A { get; } =
+                from value in x6AParser.Instance
+                select new CharVal.Inner.x6A(value);
+
+            public static Parser<CharVal.Inner.x6B> x6B { get; } =
+                from value in x6BParser.Instance
+                select new CharVal.Inner.x6B(value);
+
+            public static Parser<CharVal.Inner.x6C> x6C { get; } =
+                from value in x6CParser.Instance
+                select new CharVal.Inner.x6C(value);
+
+            public static Parser<CharVal.Inner.x6D> x6D { get; } =
+                from value in x6DParser.Instance
+                select new CharVal.Inner.x6D(value);
+
+            public static Parser<CharVal.Inner.x6E> x6E { get; } =
+                from value in x6EParser.Instance
+                select new CharVal.Inner.x6E(value);
+
+            public static Parser<CharVal.Inner.x6F> x6F { get; } =
+                from value in x6FParser.Instance
+                select new CharVal.Inner.x6F(value);
+
+            public static Parser<CharVal.Inner.x70> x70 { get; } =
+                from value in x70Parser.Instance
+                select new CharVal.Inner.x70(value);
+
+            public static Parser<CharVal.Inner.x71> x71 { get; } =
+                from value in x71Parser.Instance
+                select new CharVal.Inner.x71(value);
+
+            public static Parser<CharVal.Inner.x72> x72 { get; } =
+                from value in x72Parser.Instance
+                select new CharVal.Inner.x72(value);
+
+            public static Parser<CharVal.Inner.x73> x73 { get; } =
+                from value in x73Parser.Instance
+                select new CharVal.Inner.x73(value);
+
+            public static Parser<CharVal.Inner.x74> x74 { get; } =
+                from value in x74Parser.Instance
+                select new CharVal.Inner.x74(value);
+
+            public static Parser<CharVal.Inner.x75> x75 { get; } =
+                from value in x75Parser.Instance
+                select new CharVal.Inner.x75(value);
+
+            public static Parser<CharVal.Inner.x76> x76 { get; } =
+                from value in x76Parser.Instance
+                select new CharVal.Inner.x76(value);
+
+            public static Parser<CharVal.Inner.x77> x77 { get; } =
+                from value in x77Parser.Instance
+                select new CharVal.Inner.x77(value);
+
+            public static Parser<CharVal.Inner.x78> x78 { get; } =
+                from value in x78Parser.Instance
+                select new CharVal.Inner.x78(value);
+
+            public static Parser<CharVal.Inner.x79> x79 { get; } =
+                from value in x79Parser.Instance
+                select new CharVal.Inner.x79(value);
+
+            public static Parser<CharVal.Inner.x7A> x7A { get; } =
+                from value in x7AParser.Instance
+                select new CharVal.Inner.x7A(value);
+
+            public static Parser<CharVal.Inner.x7B> x7B { get; } =
+                from value in x7BParser.Instance
+                select new CharVal.Inner.x7B(value);
+
+            public static Parser<CharVal.Inner.x7C> x7C { get; } =
+                from value in x7CParser.Instance
+                select new CharVal.Inner.x7C(value);
+
+            public static Parser<CharVal.Inner.x7D> x7D { get; } =
+                from value in x7DParser.Instance
+                select new CharVal.Inner.x7D(value);
+
+            public static Parser<CharVal.Inner.x7E> x7E { get; } =
+                from value in x7EParser.Instance
+                select new CharVal.Inner.x7E(value);
+
+            public static Parser<CharVal.Inner> Instance { get; } =
+                x20
+                .Or<CharVal.Inner>(x21)
+                .Or(x23)
+                .Or(x24)
+                .Or(x25)
+                .Or(x26)
+                .Or(x27)
+                .Or(x28)
+                .Or(x29)
+                .Or(x2A)
+                .Or(x2B)
+                .Or(x2C)
+                .Or(x2D)
+                .Or(x2E)
+                .Or(x2F)
+                .Or(x30)
+                .Or(x31)
+                .Or(x32)
+                .Or(x33)
+                .Or(x34)
+                .Or(x35)
+                .Or(x36)
+                .Or(x37)
+                .Or(x38)
+                .Or(x39)
+                .Or(x3A)
+                .Or(x3B)
+                .Or(x3C)
+                .Or(x3D)
+                .Or(x3E)
+                .Or(x3F)
+                .Or(x40)
+                .Or(x41)
+                .Or(x42)
+                .Or(x43)
+                .Or(x44)
+                .Or(x45)
+                .Or(x46)
+                .Or(x47)
+                .Or(x48)
+                .Or(x49)
+                .Or(x4A)
+                .Or(x4B)
+                .Or(x4C)
+                .Or(x4D)
+                .Or(x4E)
+                .Or(x4F)
+                .Or(x50)
+                .Or(x51)
+                .Or(x52)
+                .Or(x53)
+                .Or(x54)
+                .Or(x55)
+                .Or(x56)
+                .Or(x57)
+                .Or(x58)
+                .Or(x59)
+                .Or(x5A)
+                .Or(x5B)
+                .Or(x5C)
+                .Or(x5D)
+                .Or(x5E)
+                .Or(x5F)
+                .Or(x60)
+                .Or(x61)
+                .Or(x62)
+                .Or(x63)
+                .Or(x64)
+                .Or(x65)
+                .Or(x66)
+                .Or(x67)
+                .Or(x68)
+                .Or(x69)
+                .Or(x6A)
+                .Or(x6B)
+                .Or(x6C)
+                .Or(x6D)
+                .Or(x6E)
+                .Or(x6F)
+                .Or(x70)
+                .Or(x71)
+                .Or(x72)
+                .Or(x73)
+                .Or(x74)
+                .Or(x75)
+                .Or(x76)
+                .Or(x77)
+                .Or(x78)
+                .Or(x79)
+                .Or(x7A)
+                .Or(x7B)
+                .Or(x7C)
+                .Or(x7D)
+                .Or(x7E);
+        }
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/CnlParser.cs b/odata/AbnfParser/CombinatorParsers/CnlParser.cs
new file mode 100644
index 0000000000..6961c6a12d
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/CnlParser.cs
@@ -0,0 +1,21 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class CnlParser
+    {
+        public static Parser<Cnl.Comment> Comment { get; } =
+            from comment in CommentParser.Instance
+            select new Cnl.Comment(comment);
+
+        public static Parser<Cnl.Newline> NewLine { get; } =
+            from crlf in CrlfParser.Instance
+            select new Cnl.Newline(crlf);
+
+        public static Parser<Cnl> Instance { get; } =
+            Comment
+            .Or<Cnl>(NewLine);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/CommentParser.cs b/odata/AbnfParser/CombinatorParsers/CommentParser.cs
new file mode 100644
index 0000000000..6b668b4e5c
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/CommentParser.cs
@@ -0,0 +1,31 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class CommentParser
+    {
+        public static Parser<Comment> Instance { get; } =
+            from semicolon in x3BParser.Instance
+            from inners in InnerParser.Instance.Many()
+            from crlf in CrlfParser.Instance
+            select new Comment(semicolon, inners, crlf);
+
+        public static class InnerParser
+        {
+            public static Parser<Comment.Inner.InnerWsp> InnerWsp { get; } =
+                from wsp in WspParser.Instance
+                select new Comment.Inner.InnerWsp(wsp);
+
+            public static Parser<Comment.Inner.InnerVchar> InnerVchar { get; } =
+                from vchar in VcharParser.Instance
+                select new Comment.Inner.InnerVchar(vchar);
+
+            public static Parser<Comment.Inner> Instance { get; } =
+                InnerWsp
+                .Or<Comment.Inner>(InnerVchar);
+        }
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/ConcatenationParser.cs b/odata/AbnfParser/CombinatorParsers/ConcatenationParser.cs
new file mode 100644
index 0000000000..798f6e2ea8
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/ConcatenationParser.cs
@@ -0,0 +1,21 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class ConcatenationParser
+    {
+        public static Parser<Concatenation> Instance { get; } =
+            from repetition in RepetitionParser.Instance
+            from inners in InnerParser.Instance.Many()
+            select new Concatenation(repetition, inners);
+
+        public static class InnerParser
+        {
+            public static Parser<Concatenation.Inner> Instance { get; } =
+                from cwsps in CwspParser.Instance.AtLeastOnce()
+                from repetition in RepetitionParser.Instance
+                select new Concatenation.Inner(cwsps, repetition);
+        }
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/AlphaParser.cs b/odata/AbnfParser/CombinatorParsers/Core/AlphaParser.cs
new file mode 100644
index 0000000000..76b4bf4776
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/AlphaParser.cs
@@ -0,0 +1,270 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class AlphaParser
+    {
+        public static Parser<Alpha.x41> x41 { get; } =
+            from value in x41Parser.Instance
+            select new Alpha.x41(value);
+
+        public static Parser<Alpha.x42> x42 { get; } =
+            from value in x42Parser.Instance
+            select new Alpha.x42(value);
+
+        public static Parser<Alpha.x43> x43 { get; } =
+            from value in x43Parser.Instance
+            select new Alpha.x43(value);
+
+        public static Parser<Alpha.x44> x44 { get; } =
+            from value in x44Parser.Instance
+            select new Alpha.x44(value);
+
+        public static Parser<Alpha.x45> x45 { get; } =
+            from value in x45Parser.Instance
+            select new Alpha.x45(value);
+
+        public static Parser<Alpha.x46> x46 { get; } =
+            from value in x46Parser.Instance
+            select new Alpha.x46(value);
+
+        public static Parser<Alpha.x47> x47 { get; } =
+            from value in x47Parser.Instance
+            select new Alpha.x47(value);
+
+        public static Parser<Alpha.x48> x48 { get; } =
+            from value in x48Parser.Instance
+            select new Alpha.x48(value);
+
+        public static Parser<Alpha.x49> x49 { get; } =
+            from value in x49Parser.Instance
+            select new Alpha.x49(value);
+
+        public static Parser<Alpha.x4A> x4A { get; } =
+            from value in x4AParser.Instance
+            select new Alpha.x4A(value);
+
+        public static Parser<Alpha.x4B> x4B { get; } =
+            from value in x4BParser.Instance
+            select new Alpha.x4B(value);
+
+        public static Parser<Alpha.x4C> x4C { get; } =
+            from value in x4CParser.Instance
+            select new Alpha.x4C(value);
+
+        public static Parser<Alpha.x4D> x4D { get; } =
+            from value in x4DParser.Instance
+            select new Alpha.x4D(value);
+
+        public static Parser<Alpha.x4E> x4E { get; } =
+            from value in x4EParser.Instance
+            select new Alpha.x4E(value);
+
+        public static Parser<Alpha.x4F> x4F { get; } =
+            from value in x4FParser.Instance
+            select new Alpha.x4F(value);
+
+        public static Parser<Alpha.x50> x50 { get; } =
+            from value in x50Parser.Instance
+            select new Alpha.x50(value);
+
+        public static Parser<Alpha.x51> x51 { get; } =
+            from value in x51Parser.Instance
+            select new Alpha.x51(value);
+
+        public static Parser<Alpha.x52> x52 { get; } =
+            from value in x52Parser.Instance
+            select new Alpha.x52(value);
+
+        public static Parser<Alpha.x53> x53 { get; } =
+            from value in x53Parser.Instance
+            select new Alpha.x53(value);
+
+        public static Parser<Alpha.x54> x54 { get; } =
+            from value in x54Parser.Instance
+            select new Alpha.x54(value);
+
+        public static Parser<Alpha.x55> x55 { get; } =
+            from value in x55Parser.Instance
+            select new Alpha.x55(value);
+
+        public static Parser<Alpha.x56> x56 { get; } =
+            from value in x56Parser.Instance
+            select new Alpha.x56(value);
+
+        public static Parser<Alpha.x57> x57 { get; } =
+            from value in x57Parser.Instance
+            select new Alpha.x57(value);
+
+        public static Parser<Alpha.x58> x58 { get; } =
+            from value in x58Parser.Instance
+            select new Alpha.x58(value);
+
+        public static Parser<Alpha.x59> x59 { get; } =
+            from value in x59Parser.Instance
+            select new Alpha.x59(value);
+
+        public static Parser<Alpha.x5A> x5A { get; } =
+            from value in x5AParser.Instance
+            select new Alpha.x5A(value);
+
+        public static Parser<Alpha.x61> x61 { get; } =
+            from value in x61Parser.Instance
+            select new Alpha.x61(value);
+
+        public static Parser<Alpha.x62> x62 { get; } =
+            from value in x62Parser.Instance
+            select new Alpha.x62(value);
+
+        public static Parser<Alpha.x63> x63 { get; } =
+            from value in x63Parser.Instance
+            select new Alpha.x63(value);
+
+        public static Parser<Alpha.x64> x64 { get; } =
+            from value in x64Parser.Instance
+            select new Alpha.x64(value);
+
+        public static Parser<Alpha.x65> x65 { get; } =
+            from value in x65Parser.Instance
+            select new Alpha.x65(value);
+
+        public static Parser<Alpha.x66> x66 { get; } =
+            from value in x66Parser.Instance
+            select new Alpha.x66(value);
+
+        public static Parser<Alpha.x67> x67 { get; } =
+            from value in x67Parser.Instance
+            select new Alpha.x67(value);
+
+        public static Parser<Alpha.x68> x68 { get; } =
+            from value in x68Parser.Instance
+            select new Alpha.x68(value);
+
+        public static Parser<Alpha.x69> x69 { get; } =
+            from value in x69Parser.Instance
+            select new Alpha.x69(value);
+
+        public static Parser<Alpha.x6A> x6A { get; } =
+            from value in x6AParser.Instance
+            select new Alpha.x6A(value);
+
+        public static Parser<Alpha.x6B> x6B { get; } =
+            from value in x6BParser.Instance
+            select new Alpha.x6B(value);
+
+        public static Parser<Alpha.x6C> x6C { get; } =
+            from value in x6CParser.Instance
+            select new Alpha.x6C(value);
+
+        public static Parser<Alpha.x6D> x6D { get; } =
+            from value in x6DParser.Instance
+            select new Alpha.x6D(value);
+
+        public static Parser<Alpha.x6E> x6E { get; } =
+            from value in x6EParser.Instance
+            select new Alpha.x6E(value);
+
+        public static Parser<Alpha.x6F> x6F { get; } =
+            from value in x6FParser.Instance
+            select new Alpha.x6F(value);
+
+        public static Parser<Alpha.x70> x70 { get; } =
+            from value in x70Parser.Instance
+            select new Alpha.x70(value);
+
+        public static Parser<Alpha.x71> x71 { get; } =
+            from value in x71Parser.Instance
+            select new Alpha.x71(value);
+
+        public static Parser<Alpha.x72> x72 { get; } =
+            from value in x72Parser.Instance
+            select new Alpha.x72(value);
+
+        public static Parser<Alpha.x73> x73 { get; } =
+            from value in x73Parser.Instance
+            select new Alpha.x73(value);
+
+        public static Parser<Alpha.x74> x74 { get; } =
+            from value in x74Parser.Instance
+            select new Alpha.x74(value);
+
+        public static Parser<Alpha.x75> x75 { get; } =
+            from value in x75Parser.Instance
+            select new Alpha.x75(value);
+
+        public static Parser<Alpha.x76> x76 { get; } =
+            from value in x76Parser.Instance
+            select new Alpha.x76(value);
+
+        public static Parser<Alpha.x77> x77 { get; } =
+            from value in x77Parser.Instance
+            select new Alpha.x77(value);
+
+        public static Parser<Alpha.x78> x78 { get; } =
+            from value in x78Parser.Instance
+            select new Alpha.x78(value);
+
+        public static Parser<Alpha.x79> x79 { get; } =
+            from value in x79Parser.Instance
+            select new Alpha.x79(value);
+
+        public static Parser<Alpha.x7A> x7A { get; } =
+            from value in x7AParser.Instance
+            select new Alpha.x7A(value);
+
+        public static Parser<Alpha> Instance { get; } =
+            x41
+            .Or<Alpha>(x42)
+            .Or(x43)
+            .Or(x44)
+            .Or(x45)
+            .Or(x46)
+            .Or(x47)
+            .Or(x48)
+            .Or(x49)
+            .Or(x4A)
+            .Or(x4B)
+            .Or(x4C)
+            .Or(x4D)
+            .Or(x4E)
+            .Or(x4F)
+            .Or(x50)
+            .Or(x51)
+            .Or(x52)
+            .Or(x53)
+            .Or(x54)
+            .Or(x55)
+            .Or(x56)
+            .Or(x57)
+            .Or(x58)
+            .Or(x59)
+            .Or(x5A)
+            .Or(x61)
+            .Or(x62)
+            .Or(x63)
+            .Or(x64)
+            .Or(x65)
+            .Or(x66)
+            .Or(x67)
+            .Or(x68)
+            .Or(x69)
+            .Or(x6A)
+            .Or(x6B)
+            .Or(x6C)
+            .Or(x6D)
+            .Or(x6E)
+            .Or(x6F)
+            .Or(x70)
+            .Or(x71)
+            .Or(x72)
+            .Or(x73)
+            .Or(x74)
+            .Or(x75)
+            .Or(x76)
+            .Or(x77)
+            .Or(x78)
+            .Or(x79)
+            .Or(x7A);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/BitParser.cs b/odata/AbnfParser/CombinatorParsers/Core/BitParser.cs
new file mode 100644
index 0000000000..8997cc35d8
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/BitParser.cs
@@ -0,0 +1,20 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class BitParser
+    {
+        public static Parser<Bit.Zero> Zero { get; } =
+            from value in x30Parser.Instance
+            select new Bit.Zero(value);
+
+        public static Parser<Bit.One> One { get; } =
+            from value in x31Parser.Instance
+            select new Bit.One(value);
+
+        public static Parser<Bit> Instance { get; } =
+            Zero
+            .Or<Bit>(One);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/CharParser.cs b/odata/AbnfParser/CombinatorParsers/Core/CharParser.cs
new file mode 100644
index 0000000000..b81c96f500
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/CharParser.cs
@@ -0,0 +1,899 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class CharParser
+    {
+        //// TODO implement this
+    }
+
+    public static class x01Parser
+    {
+        public static Parser<x01> Instance { get; } = Parse
+        .Char((char)0x01)
+        .Return(x01.Instance);
+    }
+
+    public static class x02Parser
+    {
+        public static Parser<x02> Instance { get; } = Parse
+        .Char((char)0x02)
+        .Return(x02.Instance);
+    }
+
+    public static class x03Parser
+    {
+        public static Parser<x03> Instance { get; } = Parse
+        .Char((char)0x03)
+        .Return(x03.Instance);
+    }
+
+    public static class x04Parser
+    {
+        public static Parser<x04> Instance { get; } = Parse
+        .Char((char)0x04)
+        .Return(x04.Instance);
+    }
+
+    public static class x05Parser
+    {
+        public static Parser<x05> Instance { get; } = Parse
+        .Char((char)0x05)
+        .Return(x05.Instance);
+    }
+
+    public static class x06Parser
+    {
+        public static Parser<x06> Instance { get; } = Parse
+        .Char((char)0x06)
+        .Return(x06.Instance);
+    }
+
+    public static class x07Parser
+    {
+        public static Parser<x07> Instance { get; } = Parse
+        .Char((char)0x07)
+        .Return(x07.Instance);
+    }
+
+    public static class x08Parser
+    {
+        public static Parser<x08> Instance { get; } = Parse
+        .Char((char)0x08)
+        .Return(x08.Instance);
+    }
+
+    public static class x09Parser
+    {
+        public static Parser<x09> Instance { get; } = Parse
+        .Char((char)0x09)
+        .Return(x09.Instance);
+    }
+
+    public static class x0AParser
+    {
+        public static Parser<x0A> Instance { get; } = Parse
+        .Char((char)0x0A)
+        .Return(x0A.Instance);
+    }
+
+    public static class x0BParser
+    {
+        public static Parser<x0B> Instance { get; } = Parse
+        .Char((char)0x0B)
+        .Return(x0B.Instance);
+    }
+
+    public static class x0CParser
+    {
+        public static Parser<x0C> Instance { get; } = Parse
+        .Char((char)0x0C)
+        .Return(x0C.Instance);
+    }
+
+    public static class x0DParser
+    {
+        public static Parser<x0D> Instance { get; } = Parse
+        .Char((char)0x0D)
+        .Return(x0D.Instance);
+    }
+
+    public static class x0EParser
+    {
+        public static Parser<x0E> Instance { get; } = Parse
+        .Char((char)0x0E)
+        .Return(x0E.Instance);
+    }
+
+    public static class x0FParser
+    {
+        public static Parser<x0F> Instance { get; } = Parse
+        .Char((char)0x0F)
+        .Return(x0F.Instance);
+    }
+
+    public static class x10Parser
+    {
+        public static Parser<x10> Instance { get; } = Parse
+        .Char((char)0x10)
+        .Return(x10.Instance);
+    }
+
+    public static class x11Parser
+    {
+        public static Parser<x11> Instance { get; } = Parse
+        .Char((char)0x11)
+        .Return(x11.Instance);
+    }
+
+    public static class x12Parser
+    {
+        public static Parser<x12> Instance { get; } = Parse
+        .Char((char)0x12)
+        .Return(x12.Instance);
+    }
+
+    public static class x13Parser
+    {
+        public static Parser<x13> Instance { get; } = Parse
+        .Char((char)0x13)
+        .Return(x13.Instance);
+    }
+
+    public static class x14Parser
+    {
+        public static Parser<x14> Instance { get; } = Parse
+        .Char((char)0x14)
+        .Return(x14.Instance);
+    }
+
+    public static class x15Parser
+    {
+        public static Parser<x15> Instance { get; } = Parse
+        .Char((char)0x15)
+        .Return(x15.Instance);
+    }
+
+    public static class x16Parser
+    {
+        public static Parser<x16> Instance { get; } = Parse
+        .Char((char)0x16)
+        .Return(x16.Instance);
+    }
+
+    public static class x17Parser
+    {
+        public static Parser<x17> Instance { get; } = Parse
+        .Char((char)0x17)
+        .Return(x17.Instance);
+    }
+
+    public static class x18Parser
+    {
+        public static Parser<x18> Instance { get; } = Parse
+        .Char((char)0x18)
+        .Return(x18.Instance);
+    }
+
+    public static class x19Parser
+    {
+        public static Parser<x19> Instance { get; } = Parse
+        .Char((char)0x19)
+        .Return(x19.Instance);
+    }
+
+    public static class x1AParser
+    {
+        public static Parser<x1A> Instance { get; } = Parse
+        .Char((char)0x1A)
+        .Return(x1A.Instance);
+    }
+
+    public static class x1BParser
+    {
+        public static Parser<x1B> Instance { get; } = Parse
+        .Char((char)0x1B)
+        .Return(x1B.Instance);
+    }
+
+    public static class x1CParser
+    {
+        public static Parser<x1C> Instance { get; } = Parse
+        .Char((char)0x1C)
+        .Return(x1C.Instance);
+    }
+
+    public static class x1DParser
+    {
+        public static Parser<x1D> Instance { get; } = Parse
+        .Char((char)0x1D)
+        .Return(x1D.Instance);
+    }
+
+    public static class x1EParser
+    {
+        public static Parser<x1E> Instance { get; } = Parse
+        .Char((char)0x1E)
+        .Return(x1E.Instance);
+    }
+
+    public static class x1FParser
+    {
+        public static Parser<x1F> Instance { get; } = Parse
+        .Char((char)0x1F)
+        .Return(x1F.Instance);
+    }
+
+    public static class x20Parser
+    {
+        public static Parser<x20> Instance { get; } = Parse
+        .Char((char)0x20)
+        .Return(x20.Instance);
+    }
+
+    public static class x21Parser
+    {
+        public static Parser<x21> Instance { get; } = Parse
+        .Char((char)0x21)
+        .Return(x21.Instance);
+    }
+
+    public static class x22Parser
+    {
+        public static Parser<x22> Instance { get; } = Parse
+        .Char((char)0x22)
+        .Return(x22.Instance);
+    }
+
+    public static class x23Parser
+    {
+        public static Parser<x23> Instance { get; } = Parse
+        .Char((char)0x23)
+        .Return(x23.Instance);
+    }
+
+    public static class x24Parser
+    {
+        public static Parser<x24> Instance { get; } = Parse
+        .Char((char)0x24)
+        .Return(x24.Instance);
+    }
+
+    public static class x25Parser
+    {
+        public static Parser<x25> Instance { get; } = Parse
+        .Char((char)0x25)
+        .Return(x25.Instance);
+    }
+
+    public static class x26Parser
+    {
+        public static Parser<x26> Instance { get; } = Parse
+        .Char((char)0x26)
+        .Return(x26.Instance);
+    }
+
+    public static class x27Parser
+    {
+        public static Parser<x27> Instance { get; } = Parse
+        .Char((char)0x27)
+        .Return(x27.Instance);
+    }
+
+    public static class x28Parser
+    {
+        public static Parser<x28> Instance { get; } = Parse
+        .Char((char)0x28)
+        .Return(x28.Instance);
+    }
+
+    public static class x29Parser
+    {
+        public static Parser<x29> Instance { get; } = Parse
+        .Char((char)0x29)
+        .Return(x29.Instance);
+    }
+
+    public static class x2AParser
+    {
+        public static Parser<x2A> Instance { get; } = Parse
+        .Char((char)0x2A)
+        .Return(x2A.Instance);
+    }
+
+    public static class x2BParser
+    {
+        public static Parser<x2B> Instance { get; } = Parse
+        .Char((char)0x2B)
+        .Return(x2B.Instance);
+    }
+
+    public static class x2CParser
+    {
+        public static Parser<x2C> Instance { get; } = Parse
+        .Char((char)0x2C)
+        .Return(x2C.Instance);
+    }
+
+    public static class x2DParser
+    {
+        public static Parser<x2D> Instance { get; } = Parse
+        .Char((char)0x2D)
+        .Return(x2D.Instance);
+    }
+
+    public static class x2EParser
+    {
+        public static Parser<x2E> Instance { get; } = Parse
+        .Char((char)0x2E)
+        .Return(x2E.Instance);
+    }
+
+    public static class x2FParser
+    {
+        public static Parser<x2F> Instance { get; } = Parse
+        .Char((char)0x2F)
+        .Return(x2F.Instance);
+    }
+
+    public static class x30Parser
+    {
+        public static Parser<x30> Instance { get; } = Parse
+        .Char((char)0x30)
+        .Return(x30.Instance);
+    }
+
+    public static class x31Parser
+    {
+        public static Parser<x31> Instance { get; } = Parse
+        .Char((char)0x31)
+        .Return(x31.Instance);
+    }
+
+    public static class x32Parser
+    {
+        public static Parser<x32> Instance { get; } = Parse
+        .Char((char)0x32)
+        .Return(x32.Instance);
+    }
+
+    public static class x33Parser
+    {
+        public static Parser<x33> Instance { get; } = Parse
+        .Char((char)0x33)
+        .Return(x33.Instance);
+    }
+
+    public static class x34Parser
+    {
+        public static Parser<x34> Instance { get; } = Parse
+        .Char((char)0x34)
+        .Return(x34.Instance);
+    }
+
+    public static class x35Parser
+    {
+        public static Parser<x35> Instance { get; } = Parse
+        .Char((char)0x35)
+        .Return(x35.Instance);
+    }
+
+    public static class x36Parser
+    {
+        public static Parser<x36> Instance { get; } = Parse
+        .Char((char)0x36)
+        .Return(x36.Instance);
+    }
+
+    public static class x37Parser
+    {
+        public static Parser<x37> Instance { get; } = Parse
+        .Char((char)0x37)
+        .Return(x37.Instance);
+    }
+
+    public static class x38Parser
+    {
+        public static Parser<x38> Instance { get; } = Parse
+        .Char((char)0x38)
+        .Return(x38.Instance);
+    }
+
+    public static class x39Parser
+    {
+        public static Parser<x39> Instance { get; } = Parse
+        .Char((char)0x39)
+        .Return(x39.Instance);
+    }
+
+    public static class x3AParser
+    {
+        public static Parser<x3A> Instance { get; } = Parse
+        .Char((char)0x3A)
+        .Return(x3A.Instance);
+    }
+
+    public static class x3BParser
+    {
+        public static Parser<x3B> Instance { get; } = Parse
+        .Char((char)0x3B)
+        .Return(x3B.Instance);
+    }
+
+    public static class x3CParser
+    {
+        public static Parser<x3C> Instance { get; } = Parse
+        .Char((char)0x3C)
+        .Return(x3C.Instance);
+    }
+
+    public static class x3DParser
+    {
+        public static Parser<x3D> Instance { get; } = Parse
+        .Char((char)0x3D)
+        .Return(x3D.Instance);
+    }
+
+    public static class x3EParser
+    {
+        public static Parser<x3E> Instance { get; } = Parse
+        .Char((char)0x3E)
+        .Return(x3E.Instance);
+    }
+
+    public static class x3FParser
+    {
+        public static Parser<x3F> Instance { get; } = Parse
+        .Char((char)0x3F)
+        .Return(x3F.Instance);
+    }
+
+    public static class x40Parser
+    {
+        public static Parser<x40> Instance { get; } = Parse
+        .Char((char)0x40)
+        .Return(x40.Instance);
+    }
+
+    public static class x41Parser
+    {
+        public static Parser<x41> Instance { get; } = Parse
+        .Char((char)0x41)
+        .Return(x41.Instance);
+    }
+
+    public static class x42Parser
+    {
+        public static Parser<x42> Instance { get; } = Parse
+        .Char((char)0x42)
+        .Return(x42.Instance);
+    }
+
+    public static class x43Parser
+    {
+        public static Parser<x43> Instance { get; } = Parse
+        .Char((char)0x43)
+        .Return(x43.Instance);
+    }
+
+    public static class x44Parser
+    {
+        public static Parser<x44> Instance { get; } = Parse
+        .Char((char)0x44)
+        .Return(x44.Instance);
+    }
+
+    public static class x45Parser
+    {
+        public static Parser<x45> Instance { get; } = Parse
+        .Char((char)0x45)
+        .Return(x45.Instance);
+    }
+
+    public static class x46Parser
+    {
+        public static Parser<x46> Instance { get; } = Parse
+        .Char((char)0x46)
+        .Return(x46.Instance);
+    }
+
+    public static class x47Parser
+    {
+        public static Parser<x47> Instance { get; } = Parse
+        .Char((char)0x47)
+        .Return(x47.Instance);
+    }
+
+    public static class x48Parser
+    {
+        public static Parser<x48> Instance { get; } = Parse
+        .Char((char)0x48)
+        .Return(x48.Instance);
+    }
+
+    public static class x49Parser
+    {
+        public static Parser<x49> Instance { get; } = Parse
+        .Char((char)0x49)
+        .Return(x49.Instance);
+    }
+
+    public static class x4AParser
+    {
+        public static Parser<x4A> Instance { get; } = Parse
+        .Char((char)0x4A)
+        .Return(x4A.Instance);
+    }
+
+    public static class x4BParser
+    {
+        public static Parser<x4B> Instance { get; } = Parse
+        .Char((char)0x4B)
+        .Return(x4B.Instance);
+    }
+
+    public static class x4CParser
+    {
+        public static Parser<x4C> Instance { get; } = Parse
+        .Char((char)0x4C)
+        .Return(x4C.Instance);
+    }
+
+    public static class x4DParser
+    {
+        public static Parser<x4D> Instance { get; } = Parse
+        .Char((char)0x4D)
+        .Return(x4D.Instance);
+    }
+
+    public static class x4EParser
+    {
+        public static Parser<x4E> Instance { get; } = Parse
+        .Char((char)0x4E)
+        .Return(x4E.Instance);
+    }
+
+    public static class x4FParser
+    {
+        public static Parser<x4F> Instance { get; } = Parse
+        .Char((char)0x4F)
+        .Return(x4F.Instance);
+    }
+
+    public static class x50Parser
+    {
+        public static Parser<x50> Instance { get; } = Parse
+        .Char((char)0x50)
+        .Return(x50.Instance);
+    }
+
+    public static class x51Parser
+    {
+        public static Parser<x51> Instance { get; } = Parse
+        .Char((char)0x51)
+        .Return(x51.Instance);
+    }
+
+    public static class x52Parser
+    {
+        public static Parser<x52> Instance { get; } = Parse
+        .Char((char)0x52)
+        .Return(x52.Instance);
+    }
+
+    public static class x53Parser
+    {
+        public static Parser<x53> Instance { get; } = Parse
+        .Char((char)0x53)
+        .Return(x53.Instance);
+    }
+
+    public static class x54Parser
+    {
+        public static Parser<x54> Instance { get; } = Parse
+        .Char((char)0x54)
+        .Return(x54.Instance);
+    }
+
+    public static class x55Parser
+    {
+        public static Parser<x55> Instance { get; } = Parse
+        .Char((char)0x55)
+        .Return(x55.Instance);
+    }
+
+    public static class x56Parser
+    {
+        public static Parser<x56> Instance { get; } = Parse
+        .Char((char)0x56)
+        .Return(x56.Instance);
+    }
+
+    public static class x57Parser
+    {
+        public static Parser<x57> Instance { get; } = Parse
+        .Char((char)0x57)
+        .Return(x57.Instance);
+    }
+
+    public static class x58Parser
+    {
+        public static Parser<x58> Instance { get; } = Parse
+        .Char((char)0x58)
+        .Return(x58.Instance);
+    }
+
+    public static class x59Parser
+    {
+        public static Parser<x59> Instance { get; } = Parse
+        .Char((char)0x59)
+        .Return(x59.Instance);
+    }
+
+    public static class x5AParser
+    {
+        public static Parser<x5A> Instance { get; } = Parse
+        .Char((char)0x5A)
+        .Return(x5A.Instance);
+    }
+
+    public static class x5BParser
+    {
+        public static Parser<x5B> Instance { get; } = Parse
+        .Char((char)0x5B)
+        .Return(x5B.Instance);
+    }
+
+    public static class x5CParser
+    {
+        public static Parser<x5C> Instance { get; } = Parse
+        .Char((char)0x5C)
+        .Return(x5C.Instance);
+    }
+
+    public static class x5DParser
+    {
+        public static Parser<x5D> Instance { get; } = Parse
+        .Char((char)0x5D)
+        .Return(x5D.Instance);
+    }
+
+    public static class x5EParser
+    {
+        public static Parser<x5E> Instance { get; } = Parse
+        .Char((char)0x5E)
+        .Return(x5E.Instance);
+    }
+
+    public static class x5FParser
+    {
+        public static Parser<x5F> Instance { get; } = Parse
+        .Char((char)0x5F)
+        .Return(x5F.Instance);
+    }
+
+    public static class x60Parser
+    {
+        public static Parser<x60> Instance { get; } = Parse
+        .Char((char)0x60)
+        .Return(x60.Instance);
+    }
+
+    public static class x61Parser
+    {
+        public static Parser<x61> Instance { get; } = Parse
+        .Char((char)0x61)
+        .Return(x61.Instance);
+    }
+
+    public static class x62Parser
+    {
+        public static Parser<x62> Instance { get; } = Parse
+        .Char((char)0x62)
+        .Return(x62.Instance);
+    }
+
+    public static class x63Parser
+    {
+        public static Parser<x63> Instance { get; } = Parse
+        .Char((char)0x63)
+        .Return(x63.Instance);
+    }
+
+    public static class x64Parser
+    {
+        public static Parser<x64> Instance { get; } = Parse
+        .Char((char)0x64)
+        .Return(x64.Instance);
+    }
+
+    public static class x65Parser
+    {
+        public static Parser<x65> Instance { get; } = Parse
+        .Char((char)0x65)
+        .Return(x65.Instance);
+    }
+
+    public static class x66Parser
+    {
+        public static Parser<x66> Instance { get; } = Parse
+        .Char((char)0x66)
+        .Return(x66.Instance);
+    }
+
+    public static class x67Parser
+    {
+        public static Parser<x67> Instance { get; } = Parse
+        .Char((char)0x67)
+        .Return(x67.Instance);
+    }
+
+    public static class x68Parser
+    {
+        public static Parser<x68> Instance { get; } = Parse
+        .Char((char)0x68)
+        .Return(x68.Instance);
+    }
+
+    public static class x69Parser
+    {
+        public static Parser<x69> Instance { get; } = Parse
+        .Char((char)0x69)
+        .Return(x69.Instance);
+    }
+
+    public static class x6AParser
+    {
+        public static Parser<x6A> Instance { get; } = Parse
+        .Char((char)0x6A)
+        .Return(x6A.Instance);
+    }
+
+    public static class x6BParser
+    {
+        public static Parser<x6B> Instance { get; } = Parse
+        .Char((char)0x6B)
+        .Return(x6B.Instance);
+    }
+
+    public static class x6CParser
+    {
+        public static Parser<x6C> Instance { get; } = Parse
+        .Char((char)0x6C)
+        .Return(x6C.Instance);
+    }
+
+    public static class x6DParser
+    {
+        public static Parser<x6D> Instance { get; } = Parse
+        .Char((char)0x6D)
+        .Return(x6D.Instance);
+    }
+
+    public static class x6EParser
+    {
+        public static Parser<x6E> Instance { get; } = Parse
+        .Char((char)0x6E)
+        .Return(x6E.Instance);
+    }
+
+    public static class x6FParser
+    {
+        public static Parser<x6F> Instance { get; } = Parse
+        .Char((char)0x6F)
+        .Return(x6F.Instance);
+    }
+
+    public static class x70Parser
+    {
+        public static Parser<x70> Instance { get; } = Parse
+        .Char((char)0x70)
+        .Return(x70.Instance);
+    }
+
+    public static class x71Parser
+    {
+        public static Parser<x71> Instance { get; } = Parse
+        .Char((char)0x71)
+        .Return(x71.Instance);
+    }
+
+    public static class x72Parser
+    {
+        public static Parser<x72> Instance { get; } = Parse
+        .Char((char)0x72)
+        .Return(x72.Instance);
+    }
+
+    public static class x73Parser
+    {
+        public static Parser<x73> Instance { get; } = Parse
+        .Char((char)0x73)
+        .Return(x73.Instance);
+    }
+
+    public static class x74Parser
+    {
+        public static Parser<x74> Instance { get; } = Parse
+        .Char((char)0x74)
+        .Return(x74.Instance);
+    }
+
+    public static class x75Parser
+    {
+        public static Parser<x75> Instance { get; } = Parse
+        .Char((char)0x75)
+        .Return(x75.Instance);
+    }
+
+    public static class x76Parser
+    {
+        public static Parser<x76> Instance { get; } = Parse
+        .Char((char)0x76)
+        .Return(x76.Instance);
+    }
+
+    public static class x77Parser
+    {
+        public static Parser<x77> Instance { get; } = Parse
+        .Char((char)0x77)
+        .Return(x77.Instance);
+    }
+
+    public static class x78Parser
+    {
+        public static Parser<x78> Instance { get; } = Parse
+        .Char((char)0x78)
+        .Return(x78.Instance);
+    }
+
+    public static class x79Parser
+    {
+        public static Parser<x79> Instance { get; } = Parse
+        .Char((char)0x79)
+        .Return(x79.Instance);
+    }
+
+    public static class x7AParser
+    {
+        public static Parser<x7A> Instance { get; } = Parse
+        .Char((char)0x7A)
+        .Return(x7A.Instance);
+    }
+
+    public static class x7BParser
+    {
+        public static Parser<x7B> Instance { get; } = Parse
+        .Char((char)0x7B)
+        .Return(x7B.Instance);
+    }
+
+    public static class x7CParser
+    {
+        public static Parser<x7C> Instance { get; } = Parse
+        .Char((char)0x7C)
+        .Return(x7C.Instance);
+    }
+
+    public static class x7DParser
+    {
+        public static Parser<x7D> Instance { get; } = Parse
+        .Char((char)0x7D)
+        .Return(x7D.Instance);
+    }
+
+    public static class x7EParser
+    {
+        public static Parser<x7E> Instance { get; } = Parse
+        .Char((char)0x7E)
+        .Return(x7E.Instance);
+    }
+
+    public static class x7FParser
+    {
+        public static Parser<x7F> Instance { get; } = Parse
+        .Char((char)0x7F)
+        .Return(x7F.Instance);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/CrParser.cs b/odata/AbnfParser/CombinatorParsers/Core/CrParser.cs
new file mode 100644
index 0000000000..72695c0bca
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/CrParser.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class CrParser
+    {
+        public static Parser<Cr> Instance { get; } =
+            from value in x0DParser.Instance
+            select new Cr(value);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/CrlfParser.cs b/odata/AbnfParser/CombinatorParsers/Core/CrlfParser.cs
new file mode 100644
index 0000000000..2fa623c34f
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/CrlfParser.cs
@@ -0,0 +1,13 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class CrlfParser
+    {
+        public static Parser<Crlf> Instance { get; } =
+            from cr in CrParser.Instance
+            from lf in LfParser.Instance
+            select new Crlf(cr, lf);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/DigitParser.cs b/odata/AbnfParser/CombinatorParsers/Core/DigitParser.cs
new file mode 100644
index 0000000000..eb62cfb768
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/DigitParser.cs
@@ -0,0 +1,60 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class DigitParser
+    {
+        public static Parser<Digit.x30> x30 { get; } =
+            from value in x30Parser.Instance
+            select new Digit.x30(value);
+
+        public static Parser<Digit.x31> x31 { get; } =
+            from value in x31Parser.Instance
+            select new Digit.x31(value);
+
+        public static Parser<Digit.x32> x32 { get; } =
+            from value in x32Parser.Instance
+            select new Digit.x32(value);
+
+        public static Parser<Digit.x33> x33 { get; } =
+            from value in x33Parser.Instance
+            select new Digit.x33(value);
+
+        public static Parser<Digit.x34> x34 { get; } =
+            from value in x34Parser.Instance
+            select new Digit.x34(value);
+
+        public static Parser<Digit.x35> x35 { get; } =
+            from value in x35Parser.Instance
+            select new Digit.x35(value);
+
+        public static Parser<Digit.x36> x36 { get; } =
+            from value in x36Parser.Instance
+            select new Digit.x36(value);
+
+        public static Parser<Digit.x37> x37 { get; } =
+            from value in x37Parser.Instance
+            select new Digit.x37(value);
+
+        public static Parser<Digit.x38> x38 { get; } =
+            from value in x38Parser.Instance
+            select new Digit.x38(value);
+
+        public static Parser<Digit.x39> x39 { get; } =
+            from value in x39Parser.Instance
+            select new Digit.x39(value);
+
+        public static Parser<Digit> Instance { get; } =
+            x30
+            .Or<Digit>(x31)
+            .Or(x32)
+            .Or(x33)
+            .Or(x34)
+            .Or(x35)
+            .Or(x36)
+            .Or(x37)
+            .Or(x38)
+            .Or(x39);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/DquoteParser.cs b/odata/AbnfParser/CombinatorParsers/Core/DquoteParser.cs
new file mode 100644
index 0000000000..3785655771
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/DquoteParser.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class DquoteParser
+    {
+        public static Parser<Dquote> Instance { get; } =
+            from value in x22Parser.Instance
+            select new Dquote(value);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/HexDigParser.cs b/odata/AbnfParser/CombinatorParsers/Core/HexDigParser.cs
new file mode 100644
index 0000000000..c215d46284
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/HexDigParser.cs
@@ -0,0 +1,45 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class HexDigParser
+    {
+        public static Parser<HexDig.Digit> Digit { get; } =
+            from value in DigitParser.Instance
+            select new HexDig.Digit(value);
+
+        public static Parser<HexDig.A> A { get; } =
+            from value in x41Parser.Instance
+            select new HexDig.A(value);
+
+        public static Parser<HexDig.B> B { get; } =
+            from value in x42Parser.Instance
+            select new HexDig.B(value);
+
+        public static Parser<HexDig.C> C { get; } =
+            from value in x43Parser.Instance
+            select new HexDig.C(value);
+
+        public static Parser<HexDig.D> D { get; } =
+            from value in x44Parser.Instance
+            select new HexDig.D(value);
+
+        public static Parser<HexDig.E> E { get; } =
+            from value in x45Parser.Instance
+            select new HexDig.E(value);
+
+        public static Parser<HexDig.F> F { get; } =
+            from value in x46Parser.Instance
+            select new HexDig.F(value);
+
+        public static Parser<HexDig> Instance { get; } =
+            Digit
+            .Or<HexDig>(A)
+            .Or(B)
+            .Or(C)
+            .Or(D)
+            .Or(E)
+            .Or(F);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/HtabParser.cs b/odata/AbnfParser/CombinatorParsers/Core/HtabParser.cs
new file mode 100644
index 0000000000..22e3952b9d
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/HtabParser.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class HtabParser
+    {
+        public static Parser<Htab> Instance { get; } =
+            from value in x09Parser.Instance
+            select new Htab(value);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/LfParser.cs b/odata/AbnfParser/CombinatorParsers/Core/LfParser.cs
new file mode 100644
index 0000000000..fca36b0458
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/LfParser.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class LfParser
+    {
+        public static Parser<Lf> Instance { get; } =
+            from value in x0AParser.Instance
+            select new Lf(value);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/OptionParser.cs b/odata/AbnfParser/CombinatorParsers/Core/OptionParser.cs
new file mode 100644
index 0000000000..8621ca7e01
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/OptionParser.cs
@@ -0,0 +1,16 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class OptionParser
+    {
+        public static Parser<Option> Instance { get; } =
+            from openBracket in x5BParser.Instance
+            from prefixCwsps in CwspParser.Instance.Many()
+            from alternation in AlternationParser.Instance
+            from suffixCwsps in CwspParser.Instance.Many()
+            from closeBracket in x5DParser.Instance
+            select new Option(openBracket, prefixCwsps, alternation, suffixCwsps, closeBracket);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/SpParser.cs b/odata/AbnfParser/CombinatorParsers/Core/SpParser.cs
new file mode 100644
index 0000000000..09e0b7222c
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/SpParser.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class SpParser
+    {
+        public static Parser<Sp> Instance { get; } =
+            from value in x20Parser.Instance
+            select new Sp(value);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/VcharParser.cs b/odata/AbnfParser/CombinatorParsers/Core/VcharParser.cs
new file mode 100644
index 0000000000..9934880b44
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/VcharParser.cs
@@ -0,0 +1,480 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class VcharParser
+    {
+        public static Parser<Vchar.x21> x21 { get; } =
+    from value in x21Parser.Instance
+    select new Vchar.x21(value);
+
+        public static Parser<Vchar.x22> x22 { get; } =
+            from value in x22Parser.Instance
+            select new Vchar.x22(value);
+
+        public static Parser<Vchar.x23> x23 { get; } =
+            from value in x23Parser.Instance
+            select new Vchar.x23(value);
+
+        public static Parser<Vchar.x24> x24 { get; } =
+            from value in x24Parser.Instance
+            select new Vchar.x24(value);
+
+        public static Parser<Vchar.x25> x25 { get; } =
+            from value in x25Parser.Instance
+            select new Vchar.x25(value);
+
+        public static Parser<Vchar.x26> x26 { get; } =
+            from value in x26Parser.Instance
+            select new Vchar.x26(value);
+
+        public static Parser<Vchar.x27> x27 { get; } =
+            from value in x27Parser.Instance
+            select new Vchar.x27(value);
+
+        public static Parser<Vchar.x28> x28 { get; } =
+            from value in x28Parser.Instance
+            select new Vchar.x28(value);
+
+        public static Parser<Vchar.x29> x29 { get; } =
+            from value in x29Parser.Instance
+            select new Vchar.x29(value);
+
+        public static Parser<Vchar.x2A> x2A { get; } =
+            from value in x2AParser.Instance
+            select new Vchar.x2A(value);
+
+        public static Parser<Vchar.x2B> x2B { get; } =
+            from value in x2BParser.Instance
+            select new Vchar.x2B(value);
+
+        public static Parser<Vchar.x2C> x2C { get; } =
+            from value in x2CParser.Instance
+            select new Vchar.x2C(value);
+
+        public static Parser<Vchar.x2D> x2D { get; } =
+            from value in x2DParser.Instance
+            select new Vchar.x2D(value);
+
+        public static Parser<Vchar.x2E> x2E { get; } =
+            from value in x2EParser.Instance
+            select new Vchar.x2E(value);
+
+        public static Parser<Vchar.x2F> x2F { get; } =
+            from value in x2FParser.Instance
+            select new Vchar.x2F(value);
+
+        public static Parser<Vchar.x30> x30 { get; } =
+            from value in x30Parser.Instance
+            select new Vchar.x30(value);
+
+        public static Parser<Vchar.x31> x31 { get; } =
+            from value in x31Parser.Instance
+            select new Vchar.x31(value);
+
+        public static Parser<Vchar.x32> x32 { get; } =
+            from value in x32Parser.Instance
+            select new Vchar.x32(value);
+
+        public static Parser<Vchar.x33> x33 { get; } =
+            from value in x33Parser.Instance
+            select new Vchar.x33(value);
+
+        public static Parser<Vchar.x34> x34 { get; } =
+            from value in x34Parser.Instance
+            select new Vchar.x34(value);
+
+        public static Parser<Vchar.x35> x35 { get; } =
+            from value in x35Parser.Instance
+            select new Vchar.x35(value);
+
+        public static Parser<Vchar.x36> x36 { get; } =
+            from value in x36Parser.Instance
+            select new Vchar.x36(value);
+
+        public static Parser<Vchar.x37> x37 { get; } =
+            from value in x37Parser.Instance
+            select new Vchar.x37(value);
+
+        public static Parser<Vchar.x38> x38 { get; } =
+            from value in x38Parser.Instance
+            select new Vchar.x38(value);
+
+        public static Parser<Vchar.x39> x39 { get; } =
+            from value in x39Parser.Instance
+            select new Vchar.x39(value);
+
+        public static Parser<Vchar.x3A> x3A { get; } =
+            from value in x3AParser.Instance
+            select new Vchar.x3A(value);
+
+        public static Parser<Vchar.x3B> x3B { get; } =
+            from value in x3BParser.Instance
+            select new Vchar.x3B(value);
+
+        public static Parser<Vchar.x3C> x3C { get; } =
+            from value in x3CParser.Instance
+            select new Vchar.x3C(value);
+
+        public static Parser<Vchar.x3D> x3D { get; } =
+            from value in x3DParser.Instance
+            select new Vchar.x3D(value);
+
+        public static Parser<Vchar.x3E> x3E { get; } =
+            from value in x3EParser.Instance
+            select new Vchar.x3E(value);
+
+        public static Parser<Vchar.x3F> x3F { get; } =
+            from value in x3FParser.Instance
+            select new Vchar.x3F(value);
+
+        public static Parser<Vchar.x40> x40 { get; } =
+            from value in x40Parser.Instance
+            select new Vchar.x40(value);
+
+        public static Parser<Vchar.x41> x41 { get; } =
+            from value in x41Parser.Instance
+            select new Vchar.x41(value);
+
+        public static Parser<Vchar.x42> x42 { get; } =
+            from value in x42Parser.Instance
+            select new Vchar.x42(value);
+
+        public static Parser<Vchar.x43> x43 { get; } =
+            from value in x43Parser.Instance
+            select new Vchar.x43(value);
+
+        public static Parser<Vchar.x44> x44 { get; } =
+            from value in x44Parser.Instance
+            select new Vchar.x44(value);
+
+        public static Parser<Vchar.x45> x45 { get; } =
+            from value in x45Parser.Instance
+            select new Vchar.x45(value);
+
+        public static Parser<Vchar.x46> x46 { get; } =
+            from value in x46Parser.Instance
+            select new Vchar.x46(value);
+
+        public static Parser<Vchar.x47> x47 { get; } =
+            from value in x47Parser.Instance
+            select new Vchar.x47(value);
+
+        public static Parser<Vchar.x48> x48 { get; } =
+            from value in x48Parser.Instance
+            select new Vchar.x48(value);
+
+        public static Parser<Vchar.x49> x49 { get; } =
+            from value in x49Parser.Instance
+            select new Vchar.x49(value);
+
+        public static Parser<Vchar.x4A> x4A { get; } =
+            from value in x4AParser.Instance
+            select new Vchar.x4A(value);
+
+        public static Parser<Vchar.x4B> x4B { get; } =
+            from value in x4BParser.Instance
+            select new Vchar.x4B(value);
+
+        public static Parser<Vchar.x4C> x4C { get; } =
+            from value in x4CParser.Instance
+            select new Vchar.x4C(value);
+
+        public static Parser<Vchar.x4D> x4D { get; } =
+            from value in x4DParser.Instance
+            select new Vchar.x4D(value);
+
+        public static Parser<Vchar.x4E> x4E { get; } =
+            from value in x4EParser.Instance
+            select new Vchar.x4E(value);
+
+        public static Parser<Vchar.x4F> x4F { get; } =
+            from value in x4FParser.Instance
+            select new Vchar.x4F(value);
+
+        public static Parser<Vchar.x50> x50 { get; } =
+            from value in x50Parser.Instance
+            select new Vchar.x50(value);
+
+        public static Parser<Vchar.x51> x51 { get; } =
+            from value in x51Parser.Instance
+            select new Vchar.x51(value);
+
+        public static Parser<Vchar.x52> x52 { get; } =
+            from value in x52Parser.Instance
+            select new Vchar.x52(value);
+
+        public static Parser<Vchar.x53> x53 { get; } =
+            from value in x53Parser.Instance
+            select new Vchar.x53(value);
+
+        public static Parser<Vchar.x54> x54 { get; } =
+            from value in x54Parser.Instance
+            select new Vchar.x54(value);
+
+        public static Parser<Vchar.x55> x55 { get; } =
+            from value in x55Parser.Instance
+            select new Vchar.x55(value);
+
+        public static Parser<Vchar.x56> x56 { get; } =
+            from value in x56Parser.Instance
+            select new Vchar.x56(value);
+
+        public static Parser<Vchar.x57> x57 { get; } =
+            from value in x57Parser.Instance
+            select new Vchar.x57(value);
+
+        public static Parser<Vchar.x58> x58 { get; } =
+            from value in x58Parser.Instance
+            select new Vchar.x58(value);
+
+        public static Parser<Vchar.x59> x59 { get; } =
+            from value in x59Parser.Instance
+            select new Vchar.x59(value);
+
+        public static Parser<Vchar.x5A> x5A { get; } =
+            from value in x5AParser.Instance
+            select new Vchar.x5A(value);
+
+        public static Parser<Vchar.x5B> x5B { get; } =
+            from value in x5BParser.Instance
+            select new Vchar.x5B(value);
+
+        public static Parser<Vchar.x5C> x5C { get; } =
+            from value in x5CParser.Instance
+            select new Vchar.x5C(value);
+
+        public static Parser<Vchar.x5D> x5D { get; } =
+            from value in x5DParser.Instance
+            select new Vchar.x5D(value);
+
+        public static Parser<Vchar.x5E> x5E { get; } =
+            from value in x5EParser.Instance
+            select new Vchar.x5E(value);
+
+        public static Parser<Vchar.x5F> x5F { get; } =
+            from value in x5FParser.Instance
+            select new Vchar.x5F(value);
+
+        public static Parser<Vchar.x60> x60 { get; } =
+            from value in x60Parser.Instance
+            select new Vchar.x60(value);
+
+        public static Parser<Vchar.x61> x61 { get; } =
+            from value in x61Parser.Instance
+            select new Vchar.x61(value);
+
+        public static Parser<Vchar.x62> x62 { get; } =
+            from value in x62Parser.Instance
+            select new Vchar.x62(value);
+
+        public static Parser<Vchar.x63> x63 { get; } =
+            from value in x63Parser.Instance
+            select new Vchar.x63(value);
+
+        public static Parser<Vchar.x64> x64 { get; } =
+            from value in x64Parser.Instance
+            select new Vchar.x64(value);
+
+        public static Parser<Vchar.x65> x65 { get; } =
+            from value in x65Parser.Instance
+            select new Vchar.x65(value);
+
+        public static Parser<Vchar.x66> x66 { get; } =
+            from value in x66Parser.Instance
+            select new Vchar.x66(value);
+
+        public static Parser<Vchar.x67> x67 { get; } =
+            from value in x67Parser.Instance
+            select new Vchar.x67(value);
+
+        public static Parser<Vchar.x68> x68 { get; } =
+            from value in x68Parser.Instance
+            select new Vchar.x68(value);
+
+        public static Parser<Vchar.x69> x69 { get; } =
+            from value in x69Parser.Instance
+            select new Vchar.x69(value);
+
+        public static Parser<Vchar.x6A> x6A { get; } =
+            from value in x6AParser.Instance
+            select new Vchar.x6A(value);
+
+        public static Parser<Vchar.x6B> x6B { get; } =
+            from value in x6BParser.Instance
+            select new Vchar.x6B(value);
+
+        public static Parser<Vchar.x6C> x6C { get; } =
+            from value in x6CParser.Instance
+            select new Vchar.x6C(value);
+
+        public static Parser<Vchar.x6D> x6D { get; } =
+            from value in x6DParser.Instance
+            select new Vchar.x6D(value);
+
+        public static Parser<Vchar.x6E> x6E { get; } =
+            from value in x6EParser.Instance
+            select new Vchar.x6E(value);
+
+        public static Parser<Vchar.x6F> x6F { get; } =
+            from value in x6FParser.Instance
+            select new Vchar.x6F(value);
+
+        public static Parser<Vchar.x70> x70 { get; } =
+            from value in x70Parser.Instance
+            select new Vchar.x70(value);
+
+        public static Parser<Vchar.x71> x71 { get; } =
+            from value in x71Parser.Instance
+            select new Vchar.x71(value);
+
+        public static Parser<Vchar.x72> x72 { get; } =
+            from value in x72Parser.Instance
+            select new Vchar.x72(value);
+
+        public static Parser<Vchar.x73> x73 { get; } =
+            from value in x73Parser.Instance
+            select new Vchar.x73(value);
+
+        public static Parser<Vchar.x74> x74 { get; } =
+            from value in x74Parser.Instance
+            select new Vchar.x74(value);
+
+        public static Parser<Vchar.x75> x75 { get; } =
+            from value in x75Parser.Instance
+            select new Vchar.x75(value);
+
+        public static Parser<Vchar.x76> x76 { get; } =
+            from value in x76Parser.Instance
+            select new Vchar.x76(value);
+
+        public static Parser<Vchar.x77> x77 { get; } =
+            from value in x77Parser.Instance
+            select new Vchar.x77(value);
+
+        public static Parser<Vchar.x78> x78 { get; } =
+            from value in x78Parser.Instance
+            select new Vchar.x78(value);
+
+        public static Parser<Vchar.x79> x79 { get; } =
+            from value in x79Parser.Instance
+            select new Vchar.x79(value);
+
+        public static Parser<Vchar.x7A> x7A { get; } =
+            from value in x7AParser.Instance
+            select new Vchar.x7A(value);
+
+        public static Parser<Vchar.x7B> x7B { get; } =
+            from value in x7BParser.Instance
+            select new Vchar.x7B(value);
+
+        public static Parser<Vchar.x7C> x7C { get; } =
+            from value in x7CParser.Instance
+            select new Vchar.x7C(value);
+
+        public static Parser<Vchar.x7D> x7D { get; } =
+            from value in x7DParser.Instance
+            select new Vchar.x7D(value);
+
+        public static Parser<Vchar.x7E> x7E { get; } =
+            from value in x7EParser.Instance
+            select new Vchar.x7E(value);
+
+        public static Parser<Vchar> Instance { get; } =
+            x21
+            .Or<Vchar>(x22)
+            .Or(x23)
+            .Or(x24)
+            .Or(x25)
+            .Or(x26)
+            .Or(x27)
+            .Or(x28)
+            .Or(x29)
+            .Or(x2A)
+            .Or(x2B)
+            .Or(x2C)
+            .Or(x2D)
+            .Or(x2E)
+            .Or(x2F)
+            .Or(x30)
+            .Or(x31)
+            .Or(x32)
+            .Or(x33)
+            .Or(x34)
+            .Or(x35)
+            .Or(x36)
+            .Or(x37)
+            .Or(x38)
+            .Or(x39)
+            .Or(x3A)
+            .Or(x3B)
+            .Or(x3C)
+            .Or(x3D)
+            .Or(x3E)
+            .Or(x3F)
+            .Or(x40)
+            .Or(x41)
+            .Or(x42)
+            .Or(x43)
+            .Or(x44)
+            .Or(x45)
+            .Or(x46)
+            .Or(x47)
+            .Or(x48)
+            .Or(x49)
+            .Or(x4A)
+            .Or(x4B)
+            .Or(x4C)
+            .Or(x4D)
+            .Or(x4E)
+            .Or(x4F)
+            .Or(x50)
+            .Or(x51)
+            .Or(x52)
+            .Or(x53)
+            .Or(x54)
+            .Or(x55)
+            .Or(x56)
+            .Or(x57)
+            .Or(x58)
+            .Or(x59)
+            .Or(x5A)
+            .Or(x5B)
+            .Or(x5C)
+            .Or(x5D)
+            .Or(x5E)
+            .Or(x5F)
+            .Or(x60)
+            .Or(x61)
+            .Or(x62)
+            .Or(x63)
+            .Or(x64)
+            .Or(x65)
+            .Or(x66)
+            .Or(x67)
+            .Or(x68)
+            .Or(x69)
+            .Or(x6A)
+            .Or(x6B)
+            .Or(x6C)
+            .Or(x6D)
+            .Or(x6E)
+            .Or(x6F)
+            .Or(x70)
+            .Or(x71)
+            .Or(x72)
+            .Or(x73)
+            .Or(x74)
+            .Or(x75)
+            .Or(x76)
+            .Or(x77)
+            .Or(x78)
+            .Or(x79)
+            .Or(x7A)
+            .Or(x7B)
+            .Or(x7C)
+            .Or(x7D)
+            .Or(x7E);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/Core/WspParser.cs b/odata/AbnfParser/CombinatorParsers/Core/WspParser.cs
new file mode 100644
index 0000000000..f2db5d43c8
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/Core/WspParser.cs
@@ -0,0 +1,20 @@
+namespace AbnfParser.CombinatorParsers.Core
+{
+    using AbnfParser.CstNodes.Core;
+    using Sprache;
+
+    public static class WspParser
+    {
+        public static Parser<Wsp.Space> Space { get; } =
+            from sp in SpParser.Instance
+            select new Wsp.Space(sp);
+
+        public static Parser<Wsp.Tab> Tab { get; } =
+            from htab in HtabParser.Instance
+            select new Wsp.Tab(htab);
+
+        public static Parser<Wsp> Instance { get; } =
+            Space
+            .Or<Wsp>(Tab);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/CwspParser.cs b/odata/AbnfParser/CombinatorParsers/CwspParser.cs
new file mode 100644
index 0000000000..8b612da65d
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/CwspParser.cs
@@ -0,0 +1,22 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class CwspParser
+    {
+        public static Parser<Cwsp.WspOnly> WspOnly { get; } =
+            from wsp in WspParser.Instance
+            select new Cwsp.WspOnly(wsp);
+
+        public static Parser<Cwsp.CnlAndWsp> CnlAndWsp { get; } =
+            from cnl in CnlParser.Instance
+            from wsp in WspParser.Instance
+            select new Cwsp.CnlAndWsp(cnl, wsp);
+
+        public static Parser<Cwsp> Instance { get; } =
+            WspOnly
+            .Or<Cwsp>(CnlAndWsp);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/DecValParser.cs b/odata/AbnfParser/CombinatorParsers/DecValParser.cs
new file mode 100644
index 0000000000..91548f234f
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/DecValParser.cs
@@ -0,0 +1,57 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class DecValParser
+    {
+        public static Parser<DecVal.DecsOnly> DecsOnly { get; } =
+            from d in x64Parser.Instance
+            from digits in DigitParser.Instance.AtLeastOnce()
+            select new DecVal.DecsOnly(d, digits);
+
+        public static Parser<DecVal.ConcatenatedDecs> ConcatenatedDecs { get; } = ConcatenatedDecsParser.Instance;
+
+        public static class ConcatenatedDecsParser
+        {
+            public static Parser<DecVal.ConcatenatedDecs> Instance { get; } =
+                from d in x64Parser.Instance
+                from digits in DigitParser.Instance.AtLeastOnce()
+                from inners in InnerParser.Instance.AtLeastOnce()
+                select new DecVal.ConcatenatedDecs(d, digits, inners);
+
+            public static class InnerParser
+            {
+                public static Parser<DecVal.ConcatenatedDecs.Inner> Instance { get; } =
+                    from dot in x2EParser.Instance
+                    from digits in DigitParser.Instance.AtLeastOnce()
+                    select new DecVal.ConcatenatedDecs.Inner(dot, digits);
+            }
+        }
+
+        public static Parser<DecVal.Range> Range { get; } = RangeParser.Instance;
+
+        public static class RangeParser
+        {
+            public static Parser<DecVal.Range> Instance { get; } =
+                from d in x64Parser.Instance
+                from digits in DigitParser.Instance.AtLeastOnce()
+                from inners in InnerParser.Instance.AtLeastOnce()
+                select new DecVal.Range(d, digits, inners);
+
+            public static class InnerParser
+            {
+                public static Parser<DecVal.Range.Inner> Instance { get; } =
+                    from dash in x2DParser.Instance
+                    from digits in DigitParser.Instance.AtLeastOnce()
+                    select new DecVal.Range.Inner(dash, digits);
+            }
+        }
+
+        public static Parser<DecVal> Instance { get; } =
+            DecsOnly
+            .Or<DecVal>(ConcatenatedDecs)
+            .Or(Range);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/DefinedAsParser.cs b/odata/AbnfParser/CombinatorParsers/DefinedAsParser.cs
new file mode 100644
index 0000000000..cfe65bf397
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/DefinedAsParser.cs
@@ -0,0 +1,26 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class DefinedAsParser
+    {
+        public static Parser<DefinedAs.Declaration> Declaration { get; } =
+            from prefixCwsps in CwspParser.Instance.Many()
+            from @equals in x3DParser.Instance
+            from suffixCwsps in CwspParser.Instance.Many()
+            select new DefinedAs.Declaration(prefixCwsps, @equals, suffixCwsps);
+
+        public static Parser<DefinedAs.Incremental> Incremental { get; } =
+            from prefixCwsps in CwspParser.Instance.Many()
+            from @equals in x3DParser.Instance
+            from slash in x2FParser.Instance
+            from suffixCwsps in CwspParser.Instance.Many()
+            select new DefinedAs.Incremental(prefixCwsps, @equals, slash, suffixCwsps);
+
+        public static Parser<DefinedAs> Instance { get; } =
+            Declaration
+            .Or<DefinedAs>(Incremental);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/ElementParser.cs b/odata/AbnfParser/CombinatorParsers/ElementParser.cs
new file mode 100644
index 0000000000..676d3bb5da
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/ElementParser.cs
@@ -0,0 +1,41 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class ElementParser
+    {
+        public static Parser<Element.RuleName> RuleName { get; } =
+            from value in RuleNameParser.Instance
+            select new Element.RuleName(value);
+
+        public static Parser<Element.Group> Group { get; } =
+            from value in GroupParser.Instance
+            select new Element.Group(value);
+
+        public static Parser<Element.Option> Option { get; } =
+            from value in OptionParser.Instance
+            select new Element.Option(value);
+
+        public static Parser<Element.CharVal> CharVal { get; } =
+            from value in CharValParser.Instance
+            select new Element.CharVal(value);
+
+        public static Parser<Element.NumVal> NumVal { get; } =
+            from value in NumValParser.Instance
+            select new Element.NumVal(value);
+
+        public static Parser<Element.ProseVal> ProseVal { get; } =
+            from value in ProseValParser.Instance
+            select new Element.ProseVal(value);
+
+        public static Parser<Element> Instance { get; } =
+            RuleName
+            .Or<Element>(Group)
+            .Or(Option)
+            .Or(CharVal)
+            .Or(NumVal)
+            .Or(ProseVal);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/ElementsParser.cs b/odata/AbnfParser/CombinatorParsers/ElementsParser.cs
new file mode 100644
index 0000000000..ed8bdf55f3
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/ElementsParser.cs
@@ -0,0 +1,13 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class ElementsParser
+    {
+        public static Parser<Elements> Instance { get; } =
+            from alternation in AlternationParser.Instance
+            from cwsps in CwspParser.Instance.Many()
+            select new Elements(alternation, cwsps);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/GroupParser.cs b/odata/AbnfParser/CombinatorParsers/GroupParser.cs
new file mode 100644
index 0000000000..4828d5efeb
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/GroupParser.cs
@@ -0,0 +1,17 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class GroupParser
+    {
+        public static Parser<Group> Instance { get; } =
+            from openParenthesis in x28Parser.Instance
+            from prefixCwsps in CwspParser.Instance.Many()
+            from alternation in AlternationParser.Instance
+            from suffixCwsps in CwspParser.Instance.Many()
+            from closeParenthesis in x29Parser.Instance
+            select new Group(openParenthesis, prefixCwsps, alternation, suffixCwsps, closeParenthesis);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/HexValParser.cs b/odata/AbnfParser/CombinatorParsers/HexValParser.cs
new file mode 100644
index 0000000000..5594020186
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/HexValParser.cs
@@ -0,0 +1,57 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class HexValParser
+    {
+        public static Parser<HexVal.HexOnly> HexOnly { get; } =
+            from x in x78Parser.Instance
+            from hexDigs in HexDigParser.Instance.AtLeastOnce()
+            select new HexVal.HexOnly(x, hexDigs);
+
+        public static Parser<HexVal.ConcatenatedHex> ConcatenatedHex { get; } = ConcatenatedHexParser.Instance;
+
+        public static class ConcatenatedHexParser
+        {
+            public static Parser<HexVal.ConcatenatedHex> Instance { get; } =
+                from x in x78Parser.Instance
+                from hexDigs in HexDigParser.Instance.AtLeastOnce()
+                from inners in InnerParser.Instance.AtLeastOnce()
+                select new HexVal.ConcatenatedHex(x, hexDigs, inners);
+
+            public static class InnerParser
+            {
+                public static Parser<HexVal.ConcatenatedHex.Inner> Instance { get; } =
+                    from dot in x2EParser.Instance
+                    from hexDigs in HexDigParser.Instance.AtLeastOnce()
+                    select new HexVal.ConcatenatedHex.Inner(dot, hexDigs);
+            }
+        }
+
+        public static Parser<HexVal.Range> Range { get; } = RangeParser.Instance;
+
+        public static class RangeParser
+        {
+            public static Parser<HexVal.Range> Instance { get; } =
+                from x in x78Parser.Instance
+                from hexDigs in HexDigParser.Instance.AtLeastOnce()
+                from inners in InnerParser.Instance.AtLeastOnce()
+                select new HexVal.Range(x, hexDigs, inners);
+
+            public static class InnerParser
+            {
+                public static Parser<HexVal.Range.Inner> Instance { get; } =
+                    from dash in x2DParser.Instance
+                    from hexDigs in HexDigParser.Instance.AtLeastOnce()
+                    select new HexVal.Range.Inner(dash, hexDigs);
+            }
+        }
+
+        public static Parser<HexVal> Instance { get; } = //// TODO you originally wrote this as hexonly.or(concatenated).or(range); how can you know to do it in this order instead?
+            ConcatenatedHex
+            .Or<HexVal>(Range)
+            .Or(HexOnly);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/NumValParser.cs b/odata/AbnfParser/CombinatorParsers/NumValParser.cs
new file mode 100644
index 0000000000..1c41506285
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/NumValParser.cs
@@ -0,0 +1,29 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class NumValParser
+    {
+        public static Parser<NumVal.BinVal> BinVal { get; } =
+            from percent in x25Parser.Instance
+            from value in BinValParser.Instance
+            select new NumVal.BinVal(percent, value);
+
+        public static Parser<NumVal.DecVal> DecVal { get; } =
+            from percent in x25Parser.Instance
+            from value in DecValParser.Instance
+            select new NumVal.DecVal(percent, value);
+
+        public static Parser<NumVal.HexVal> HexVal { get; } =
+            from percent in x25Parser.Instance
+            from value in HexValParser.Instance
+            select new NumVal.HexVal(percent, value);
+
+        public static Parser<NumVal> Instance { get; } =
+            BinVal
+            .Or<NumVal>(DecVal)
+            .Or(HexVal);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/ProseValParser.cs b/odata/AbnfParser/CombinatorParsers/ProseValParser.cs
new file mode 100644
index 0000000000..5bca5e3471
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/ProseValParser.cs
@@ -0,0 +1,669 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class ProseValParser
+    {
+        public static Parser<ProseVal.x20> x20 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x20Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x20(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x21> x21 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x21Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x21(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x22> x22 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x22Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x22(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x23> x23 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x23Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x23(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x24> x24 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x24Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x24(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x25> x25 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x25Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x25(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x26> x26 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x26Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x26(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x27> x27 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x27Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x27(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x28> x28 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x28Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x28(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x29> x29 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x29Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x29(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x2A> x2A { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x2AParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x2A(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x2B> x2B { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x2BParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x2B(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x2C> x2C { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x2CParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x2C(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x2D> x2D { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x2DParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x2D(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x2E> x2E { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x2EParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x2E(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x2F> x2F { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x2FParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x2F(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x30> x30 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x30Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x30(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x31> x31 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x31Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x31(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x32> x32 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x32Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x32(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x33> x33 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x33Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x33(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x34> x34 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x34Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x34(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x35> x35 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x35Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x35(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x36> x36 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x36Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x36(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x37> x37 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x37Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x37(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x38> x38 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x38Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x38(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x39> x39 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x39Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x39(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x3A> x3A { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x3AParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x3A(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x3B> x3B { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x3BParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x3B(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x3C> x3C { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x3CParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x3C(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x3D> x3D { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x3DParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x3D(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x3F> x3F { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x3FParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x3F(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x40> x40 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x40Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x40(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x41> x41 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x41Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x41(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x42> x42 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x42Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x42(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x43> x43 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x43Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x43(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x44> x44 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x44Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x44(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x45> x45 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x45Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x45(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x46> x46 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x46Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x46(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x47> x47 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x47Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x47(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x48> x48 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x48Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x48(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x49> x49 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x49Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x49(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x4A> x4A { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x4AParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x4A(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x4B> x4B { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x4BParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x4B(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x4C> x4C { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x4CParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x4C(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x4D> x4D { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x4DParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x4D(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x4E> x4E { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x4EParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x4E(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x4F> x4F { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x4FParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x4F(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x50> x50 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x50Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x50(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x51> x51 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x51Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x51(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x52> x52 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x52Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x52(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x53> x53 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x53Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x53(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x54> x54 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x54Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x54(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x55> x55 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x55Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x55(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x56> x56 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x56Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x56(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x57> x57 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x57Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x57(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x58> x58 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x58Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x58(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x59> x59 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x59Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x59(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x5A> x5A { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x5AParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x5A(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x5B> x5B { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x5BParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x5B(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x5C> x5C { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x5CParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x5C(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x5D> x5D { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x5DParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x5D(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x5E> x5E { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x5EParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x5E(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x5F> x5F { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x5FParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x5F(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x60> x60 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x60Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x60(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x61> x61 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x61Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x61(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x62> x62 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x62Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x62(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x63> x63 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x63Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x63(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x64> x64 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x64Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x64(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x65> x65 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x65Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x65(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x66> x66 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x66Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x66(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x67> x67 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x67Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x67(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x68> x68 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x68Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x68(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x69> x69 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x69Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x69(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x6A> x6A { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x6AParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x6A(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x6B> x6B { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x6BParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x6B(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x6C> x6C { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x6CParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x6C(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x6D> x6D { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x6DParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x6D(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x6E> x6E { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x6EParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x6E(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x6F> x6F { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x6FParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x6F(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x70> x70 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x70Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x70(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x71> x71 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x71Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x71(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x72> x72 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x72Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x72(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x73> x73 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x73Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x73(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x74> x74 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x74Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x74(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x75> x75 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x75Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x75(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x76> x76 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x76Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x76(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x77> x77 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x77Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x77(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x78> x78 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x78Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x78(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x79> x79 { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x79Parser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x79(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x7A> x7A { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x7AParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x7A(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x7B> x7B { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x7BParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x7B(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x7C> x7C { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x7CParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x7C(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x7D> x7D { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x7DParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x7D(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal.x7E> x7E { get; } =
+            from lessThan in x3CParser.Instance
+            from value in x7EParser.Instance
+            from greaterThan in x3EParser.Instance
+            select new ProseVal.x7E(lessThan, value, greaterThan);
+
+        public static Parser<ProseVal> Instance { get; } =
+            x20
+            .Or<ProseVal>(x21)
+            .Or(x22)
+            .Or(x23)
+            .Or(x24)
+            .Or(x25)
+            .Or(x26)
+            .Or(x27)
+            .Or(x28)
+            .Or(x29)
+            .Or(x2A)
+            .Or(x2B)
+            .Or(x2C)
+            .Or(x2D)
+            .Or(x2E)
+            .Or(x2F)
+            .Or(x30)
+            .Or(x31)
+            .Or(x32)
+            .Or(x33)
+            .Or(x34)
+            .Or(x35)
+            .Or(x36)
+            .Or(x37)
+            .Or(x38)
+            .Or(x39)
+            .Or(x3A)
+            .Or(x3B)
+            .Or(x3C)
+            .Or(x3D)
+            .Or(x3F)
+            .Or(x40)
+            .Or(x41)
+            .Or(x42)
+            .Or(x43)
+            .Or(x44)
+            .Or(x45)
+            .Or(x46)
+            .Or(x47)
+            .Or(x48)
+            .Or(x49)
+            .Or(x4A)
+            .Or(x4B)
+            .Or(x4C)
+            .Or(x4D)
+            .Or(x4E)
+            .Or(x4F)
+            .Or(x50)
+            .Or(x51)
+            .Or(x52)
+            .Or(x53)
+            .Or(x54)
+            .Or(x55)
+            .Or(x56)
+            .Or(x57)
+            .Or(x58)
+            .Or(x59)
+            .Or(x5A)
+            .Or(x5B)
+            .Or(x5C)
+            .Or(x5D)
+            .Or(x5E)
+            .Or(x5F)
+            .Or(x60)
+            .Or(x61)
+            .Or(x62)
+            .Or(x63)
+            .Or(x64)
+            .Or(x65)
+            .Or(x66)
+            .Or(x67)
+            .Or(x68)
+            .Or(x69)
+            .Or(x6A)
+            .Or(x6B)
+            .Or(x6C)
+            .Or(x6D)
+            .Or(x6E)
+            .Or(x6F)
+            .Or(x70)
+            .Or(x71)
+            .Or(x72)
+            .Or(x73)
+            .Or(x74)
+            .Or(x75)
+            .Or(x76)
+            .Or(x77)
+            .Or(x78)
+            .Or(x79)
+            .Or(x7A)
+            .Or(x7B)
+            .Or(x7C)
+            .Or(x7D)
+            .Or(x7E);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/RepeatParser.cs b/odata/AbnfParser/CombinatorParsers/RepeatParser.cs
new file mode 100644
index 0000000000..6ac9f4bc24
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/RepeatParser.cs
@@ -0,0 +1,23 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class RepeatParser
+    {
+        public static Parser<Repeat.Count> Count { get; } =
+            from digits in DigitParser.Instance.AtLeastOnce()
+            select new Repeat.Count(digits);
+
+        public static Parser<Repeat.Range> Range { get; } =
+            from prefixDigits in DigitParser.Instance.Many()
+            from asterisk in x2AParser.Instance
+            from suffixDigits in DigitParser.Instance.Many()
+            select new Repeat.Range(prefixDigits, asterisk, suffixDigits);
+
+        public static Parser<Repeat> Instance { get; } =
+            Range
+            .Or<Repeat>(Count); //// TODO reversing range and count breaks `rulelist = 1*( rule / (*c-wsp c-nl) )`
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/RepetitionParser.cs b/odata/AbnfParser/CombinatorParsers/RepetitionParser.cs
new file mode 100644
index 0000000000..9e1018421f
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/RepetitionParser.cs
@@ -0,0 +1,21 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class RepetitionParser
+    {
+        public static Parser<Repetition.ElementOnly> ElementOnly { get; } =
+            from element in ElementParser.Instance
+            select new Repetition.ElementOnly(element);
+
+        public static Parser<Repetition.RepeatAndElement> RepeatAndElement { get; } =
+            from repeat in RepeatParser.Instance
+            from element in ElementParser.Instance
+            select new Repetition.RepeatAndElement(repeat, element);
+
+        public static Parser<Repetition> Instance { get; } =
+            ElementOnly
+            .Or<Repetition>(RepeatAndElement);
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/RuleListParser.cs b/odata/AbnfParser/CombinatorParsers/RuleListParser.cs
new file mode 100644
index 0000000000..da3d95e7ef
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/RuleListParser.cs
@@ -0,0 +1,28 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class RuleListParser
+    {
+        public static Parser<RuleList> Instance { get; } =
+            from inners in InnerParser.Instance.AtLeastOnce()
+            select new RuleList(inners);
+
+        public static class InnerParser
+        {
+            public static Parser<RuleList.Inner.RuleInner> RuleInner { get; } =
+                from rule in RuleParser.Instance
+                select new RuleList.Inner.RuleInner(rule);
+
+            public static Parser<RuleList.Inner.CommentInner> CommentInner { get; } =
+                from cwsps in CwspParser.Instance.Many()
+                from cnl in CnlParser.Instance
+                select new RuleList.Inner.CommentInner(cwsps, cnl);
+
+            public static Parser<RuleList.Inner> Instance { get; } =
+                RuleInner
+                .Or<RuleList.Inner>(CommentInner);
+        }
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/RuleNameParser.cs b/odata/AbnfParser/CombinatorParsers/RuleNameParser.cs
new file mode 100644
index 0000000000..29f087f51a
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/RuleNameParser.cs
@@ -0,0 +1,34 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CombinatorParsers.Core;
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class RuleNameParser
+    {
+        public static Parser<RuleName> Instance { get; } =
+            from alpha in AlphaParser.Instance
+            from inners in InnerParser.Instance.Many()
+            select new RuleName(alpha, inners);
+
+        public static class InnerParser
+        {
+            public static Parser<RuleName.Inner.AlphaInner> AlphaInner { get; } =
+                from alpha in AlphaParser.Instance
+                select new RuleName.Inner.AlphaInner(alpha);
+
+            public static Parser<RuleName.Inner.DigitInner> DigitInner { get; } =
+                from digit in DigitParser.Instance
+                select new RuleName.Inner.DigitInner(digit);
+
+            public static Parser<RuleName.Inner.DashInner> DashInner { get; } =
+                from dash in x2DParser.Instance
+                select new RuleName.Inner.DashInner(dash);
+
+            public static Parser<RuleName.Inner> Instance { get; } =
+                AlphaInner
+                .Or<RuleName.Inner>(DigitInner)
+                .Or(DashInner);
+        }
+    }
+}
diff --git a/odata/AbnfParser/CombinatorParsers/RuleParser.cs b/odata/AbnfParser/CombinatorParsers/RuleParser.cs
new file mode 100644
index 0000000000..8fe21fb805
--- /dev/null
+++ b/odata/AbnfParser/CombinatorParsers/RuleParser.cs
@@ -0,0 +1,15 @@
+namespace AbnfParser.CombinatorParsers
+{
+    using AbnfParser.CstNodes;
+    using Sprache;
+
+    public static class RuleParser
+    {
+        public static Parser<Rule> Instance { get; } =
+            from ruleName in RuleNameParser.Instance
+            from definedAs in DefinedAsParser.Instance
+            from elements in ElementsParser.Instance
+            from cnl in CnlParser.Instance
+            select new Rule(ruleName, definedAs, elements, cnl);
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Alternation.cs b/odata/AbnfParser/CstNodes/Alternation.cs
new file mode 100644
index 0000000000..74f67b3cec
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Alternation.cs
@@ -0,0 +1,34 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public sealed class Alternation
+    {
+        public Alternation(Concatenation concatenation, IEnumerable<Inner> inners)
+        {
+            Concatenation = concatenation;
+            Inners = inners;
+        }
+
+        public Concatenation Concatenation { get; }
+        public IEnumerable<Inner> Inners { get; }
+
+        public sealed class Inner
+        {
+            public Inner(IEnumerable<Cwsp> prefixCwsps, x2F slash, IEnumerable<Cwsp> suffixCwsps, Concatenation concatenation)
+            {
+                PrefixCwsps = prefixCwsps;
+                Slash = slash;
+                SuffixCwsps = suffixCwsps;
+                Concatenation = concatenation;
+            }
+
+            public IEnumerable<Cwsp> PrefixCwsps { get; }
+            public x2F Slash { get; }
+            public IEnumerable<Cwsp> SuffixCwsps { get; }
+            public Concatenation Concatenation { get; }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/BinVal.cs b/odata/AbnfParser/CstNodes/BinVal.cs
new file mode 100644
index 0000000000..2d9f80092d
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/BinVal.cs
@@ -0,0 +1,105 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+    using System.Collections.Generic;
+
+    public abstract class BinVal
+    {
+        private BinVal()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(BinVal node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(BitsOnly node, TContext context);
+            protected internal abstract TResult Accept(ConcatenatedBits node, TContext context);
+            protected internal abstract TResult Accept(Range node, TContext context);
+        }
+
+        public sealed class BitsOnly : BinVal
+        {
+            public BitsOnly(x62 b, IEnumerable<Bit> bits)
+            {
+                B = b;
+                Bits = bits; //// TODO assert one or more
+            }
+
+            public x62 B { get; }
+            public IEnumerable<Bit> Bits { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ConcatenatedBits : BinVal
+        {
+            public ConcatenatedBits(x62 b, IEnumerable<Bit> bits, IEnumerable<Inner> inners)
+            {
+                B = b;
+                Bits = bits; //// TODO assert one or more
+                Inners = inners; //// TODO assert one or more
+            }
+
+            public x62 B { get; }
+            public IEnumerable<Bit> Bits { get; }
+            public IEnumerable<Inner> Inners { get; }
+
+            public sealed class Inner
+            {
+                public Inner(x2E dot, IEnumerable<Bit> bits)
+                {
+                    Dot = dot;
+                    Bits = bits; //// TODO assert one or more
+                }
+
+                public x2E Dot { get; }
+                public IEnumerable<Bit> Bits { get; }
+            }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Range : BinVal
+        {
+            public Range(x62 b, IEnumerable<Bit> bits, IEnumerable<Inner> inners)
+            {
+                B = b;
+                Bits = bits; //// TODO assert one or more
+                Inners = inners; //// TODO assert one or more
+            }
+
+            public x62 B { get; }
+            public IEnumerable<Bit> Bits { get; }
+            public IEnumerable<Inner> Inners { get; }
+
+            public sealed class Inner
+            {
+                public Inner(x2D dash, IEnumerable<Bit> bits)
+                {
+                    Dash = dash;
+                    Bits = bits; //// TODO assert one or more
+                }
+
+                public x2D Dash { get; }
+                public IEnumerable<Bit> Bits { get; }
+            }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/CharVal.cs b/odata/AbnfParser/CstNodes/CharVal.cs
new file mode 100644
index 0000000000..d776ec248c
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/CharVal.cs
@@ -0,0 +1,1542 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public sealed class CharVal
+    {
+        public CharVal(Dquote openDquote, IEnumerable<Inner> inners, Dquote closeDquote)
+        {
+            OpenDquote = openDquote;
+            Inners = inners;
+            CloseDquote = closeDquote;
+        }
+
+        public Dquote OpenDquote { get; }
+        public IEnumerable<Inner> Inners { get; }
+        public Dquote CloseDquote { get; }
+
+        public abstract class Inner
+        {
+            private Inner()
+            {
+            }
+
+            public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+            public abstract class Visitor<TResult, TContext>
+            {
+                public TResult Visit(Inner node, TContext context)
+                {
+                    return node.Dispatch(this, context);
+                }
+
+                protected internal abstract TResult Accept(x20 node, TContext context);
+                protected internal abstract TResult Accept(x21 node, TContext context);
+                protected internal abstract TResult Accept(x23 node, TContext context);
+                protected internal abstract TResult Accept(x24 node, TContext context);
+                protected internal abstract TResult Accept(x25 node, TContext context);
+                protected internal abstract TResult Accept(x26 node, TContext context);
+                protected internal abstract TResult Accept(x27 node, TContext context);
+                protected internal abstract TResult Accept(x28 node, TContext context);
+                protected internal abstract TResult Accept(x29 node, TContext context);
+                protected internal abstract TResult Accept(x2A node, TContext context);
+                protected internal abstract TResult Accept(x2B node, TContext context);
+                protected internal abstract TResult Accept(x2C node, TContext context);
+                protected internal abstract TResult Accept(x2D node, TContext context);
+                protected internal abstract TResult Accept(x2E node, TContext context);
+                protected internal abstract TResult Accept(x2F node, TContext context);
+                protected internal abstract TResult Accept(x30 node, TContext context);
+                protected internal abstract TResult Accept(x31 node, TContext context);
+                protected internal abstract TResult Accept(x32 node, TContext context);
+                protected internal abstract TResult Accept(x33 node, TContext context);
+                protected internal abstract TResult Accept(x34 node, TContext context);
+                protected internal abstract TResult Accept(x35 node, TContext context);
+                protected internal abstract TResult Accept(x36 node, TContext context);
+                protected internal abstract TResult Accept(x37 node, TContext context);
+                protected internal abstract TResult Accept(x38 node, TContext context);
+                protected internal abstract TResult Accept(x39 node, TContext context);
+                protected internal abstract TResult Accept(x3A node, TContext context);
+                protected internal abstract TResult Accept(x3B node, TContext context);
+                protected internal abstract TResult Accept(x3C node, TContext context);
+                protected internal abstract TResult Accept(x3D node, TContext context);
+                protected internal abstract TResult Accept(x3E node, TContext context);
+                protected internal abstract TResult Accept(x3F node, TContext context);
+                protected internal abstract TResult Accept(x40 node, TContext context);
+                protected internal abstract TResult Accept(x41 node, TContext context);
+                protected internal abstract TResult Accept(x42 node, TContext context);
+                protected internal abstract TResult Accept(x43 node, TContext context);
+                protected internal abstract TResult Accept(x44 node, TContext context);
+                protected internal abstract TResult Accept(x45 node, TContext context);
+                protected internal abstract TResult Accept(x46 node, TContext context);
+                protected internal abstract TResult Accept(x47 node, TContext context);
+                protected internal abstract TResult Accept(x48 node, TContext context);
+                protected internal abstract TResult Accept(x49 node, TContext context);
+                protected internal abstract TResult Accept(x4A node, TContext context);
+                protected internal abstract TResult Accept(x4B node, TContext context);
+                protected internal abstract TResult Accept(x4C node, TContext context);
+                protected internal abstract TResult Accept(x4D node, TContext context);
+                protected internal abstract TResult Accept(x4E node, TContext context);
+                protected internal abstract TResult Accept(x4F node, TContext context);
+                protected internal abstract TResult Accept(x50 node, TContext context);
+                protected internal abstract TResult Accept(x51 node, TContext context);
+                protected internal abstract TResult Accept(x52 node, TContext context);
+                protected internal abstract TResult Accept(x53 node, TContext context);
+                protected internal abstract TResult Accept(x54 node, TContext context);
+                protected internal abstract TResult Accept(x55 node, TContext context);
+                protected internal abstract TResult Accept(x56 node, TContext context);
+                protected internal abstract TResult Accept(x57 node, TContext context);
+                protected internal abstract TResult Accept(x58 node, TContext context);
+                protected internal abstract TResult Accept(x59 node, TContext context);
+                protected internal abstract TResult Accept(x5A node, TContext context);
+                protected internal abstract TResult Accept(x5B node, TContext context);
+                protected internal abstract TResult Accept(x5C node, TContext context);
+                protected internal abstract TResult Accept(x5D node, TContext context);
+                protected internal abstract TResult Accept(x5E node, TContext context);
+                protected internal abstract TResult Accept(x5F node, TContext context);
+                protected internal abstract TResult Accept(x60 node, TContext context);
+                protected internal abstract TResult Accept(x61 node, TContext context);
+                protected internal abstract TResult Accept(x62 node, TContext context);
+                protected internal abstract TResult Accept(x63 node, TContext context);
+                protected internal abstract TResult Accept(x64 node, TContext context);
+                protected internal abstract TResult Accept(x65 node, TContext context);
+                protected internal abstract TResult Accept(x66 node, TContext context);
+                protected internal abstract TResult Accept(x67 node, TContext context);
+                protected internal abstract TResult Accept(x68 node, TContext context);
+                protected internal abstract TResult Accept(x69 node, TContext context);
+                protected internal abstract TResult Accept(x6A node, TContext context);
+                protected internal abstract TResult Accept(x6B node, TContext context);
+                protected internal abstract TResult Accept(x6C node, TContext context);
+                protected internal abstract TResult Accept(x6D node, TContext context);
+                protected internal abstract TResult Accept(x6E node, TContext context);
+                protected internal abstract TResult Accept(x6F node, TContext context);
+                protected internal abstract TResult Accept(x70 node, TContext context);
+                protected internal abstract TResult Accept(x71 node, TContext context);
+                protected internal abstract TResult Accept(x72 node, TContext context);
+                protected internal abstract TResult Accept(x73 node, TContext context);
+                protected internal abstract TResult Accept(x74 node, TContext context);
+                protected internal abstract TResult Accept(x75 node, TContext context);
+                protected internal abstract TResult Accept(x76 node, TContext context);
+                protected internal abstract TResult Accept(x77 node, TContext context);
+                protected internal abstract TResult Accept(x78 node, TContext context);
+                protected internal abstract TResult Accept(x79 node, TContext context);
+                protected internal abstract TResult Accept(x7A node, TContext context);
+                protected internal abstract TResult Accept(x7B node, TContext context);
+                protected internal abstract TResult Accept(x7C node, TContext context);
+                protected internal abstract TResult Accept(x7D node, TContext context);
+                protected internal abstract TResult Accept(x7E node, TContext context);
+            }
+
+            public sealed class x20 : Inner
+            {
+                public x20(Core.x20 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x20 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x21 : Inner
+            {
+                public x21(Core.x21 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x21 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x23 : Inner
+            {
+                public x23(Core.x23 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x23 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x24 : Inner
+            {
+                public x24(Core.x24 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x24 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x25 : Inner
+            {
+                public x25(Core.x25 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x25 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x26 : Inner
+            {
+                public x26(Core.x26 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x26 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x27 : Inner
+            {
+                public x27(Core.x27 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x27 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x28 : Inner
+            {
+                public x28(Core.x28 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x28 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x29 : Inner
+            {
+                public x29(Core.x29 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x29 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x2A : Inner
+            {
+                public x2A(Core.x2A value)
+                {
+                    Value = value;
+                }
+
+                public Core.x2A Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x2B : Inner
+            {
+                public x2B(Core.x2B value)
+                {
+                    Value = value;
+                }
+
+                public Core.x2B Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x2C : Inner
+            {
+                public x2C(Core.x2C value)
+                {
+                    Value = value;
+                }
+
+                public Core.x2C Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x2D : Inner
+            {
+                public x2D(Core.x2D value)
+                {
+                    Value = value;
+                }
+
+                public Core.x2D Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x2E : Inner
+            {
+                public x2E(Core.x2E value)
+                {
+                    Value = value;
+                }
+
+                public Core.x2E Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x2F : Inner
+            {
+                public x2F(Core.x2F value)
+                {
+                    Value = value;
+                }
+
+                public Core.x2F Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x30 : Inner
+            {
+                public x30(Core.x30 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x30 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x31 : Inner
+            {
+                public x31(Core.x31 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x31 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x32 : Inner
+            {
+                public x32(Core.x32 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x32 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x33 : Inner
+            {
+                public x33(Core.x33 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x33 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x34 : Inner
+            {
+                public x34(Core.x34 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x34 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x35 : Inner
+            {
+                public x35(Core.x35 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x35 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x36 : Inner
+            {
+                public x36(Core.x36 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x36 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x37 : Inner
+            {
+                public x37(Core.x37 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x37 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x38 : Inner
+            {
+                public x38(Core.x38 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x38 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x39 : Inner
+            {
+                public x39(Core.x39 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x39 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x3A : Inner
+            {
+                public x3A(Core.x3A value)
+                {
+                    Value = value;
+                }
+
+                public Core.x3A Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x3B : Inner
+            {
+                public x3B(Core.x3B value)
+                {
+                    Value = value;
+                }
+
+                public Core.x3B Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x3C : Inner
+            {
+                public x3C(Core.x3C value)
+                {
+                    Value = value;
+                }
+
+                public Core.x3C Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x3D : Inner
+            {
+                public x3D(Core.x3D value)
+                {
+                    Value = value;
+                }
+
+                public Core.x3D Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x3E : Inner
+            {
+                public x3E(Core.x3E value)
+                {
+                    Value = value;
+                }
+
+                public Core.x3E Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x3F : Inner
+            {
+                public x3F(Core.x3F value)
+                {
+                    Value = value;
+                }
+
+                public Core.x3F Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x40 : Inner
+            {
+                public x40(Core.x40 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x40 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x41 : Inner
+            {
+                public x41(Core.x41 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x41 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x42 : Inner
+            {
+                public x42(Core.x42 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x42 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x43 : Inner
+            {
+                public x43(Core.x43 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x43 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x44 : Inner
+            {
+                public x44(Core.x44 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x44 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x45 : Inner
+            {
+                public x45(Core.x45 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x45 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x46 : Inner
+            {
+                public x46(Core.x46 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x46 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x47 : Inner
+            {
+                public x47(Core.x47 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x47 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x48 : Inner
+            {
+                public x48(Core.x48 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x48 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x49 : Inner
+            {
+                public x49(Core.x49 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x49 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x4A : Inner
+            {
+                public x4A(Core.x4A value)
+                {
+                    Value = value;
+                }
+
+                public Core.x4A Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x4B : Inner
+            {
+                public x4B(Core.x4B value)
+                {
+                    Value = value;
+                }
+
+                public Core.x4B Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x4C : Inner
+            {
+                public x4C(Core.x4C value)
+                {
+                    Value = value;
+                }
+
+                public Core.x4C Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x4D : Inner
+            {
+                public x4D(Core.x4D value)
+                {
+                    Value = value;
+                }
+
+                public Core.x4D Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x4E : Inner
+            {
+                public x4E(Core.x4E value)
+                {
+                    Value = value;
+                }
+
+                public Core.x4E Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x4F : Inner
+            {
+                public x4F(Core.x4F value)
+                {
+                    Value = value;
+                }
+
+                public Core.x4F Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x50 : Inner
+            {
+                public x50(Core.x50 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x50 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x51 : Inner
+            {
+                public x51(Core.x51 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x51 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x52 : Inner
+            {
+                public x52(Core.x52 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x52 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x53 : Inner
+            {
+                public x53(Core.x53 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x53 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x54 : Inner
+            {
+                public x54(Core.x54 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x54 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x55 : Inner
+            {
+                public x55(Core.x55 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x55 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x56 : Inner
+            {
+                public x56(Core.x56 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x56 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x57 : Inner
+            {
+                public x57(Core.x57 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x57 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x58 : Inner
+            {
+                public x58(Core.x58 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x58 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x59 : Inner
+            {
+                public x59(Core.x59 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x59 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x5A : Inner
+            {
+                public x5A(Core.x5A value)
+                {
+                    Value = value;
+                }
+
+                public Core.x5A Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x5B : Inner
+            {
+                public x5B(Core.x5B value)
+                {
+                    Value = value;
+                }
+
+                public Core.x5B Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x5C : Inner
+            {
+                public x5C(Core.x5C value)
+                {
+                    Value = value;
+                }
+
+                public Core.x5C Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x5D : Inner
+            {
+                public x5D(Core.x5D value)
+                {
+                    Value = value;
+                }
+
+                public Core.x5D Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x5E : Inner
+            {
+                public x5E(Core.x5E value)
+                {
+                    Value = value;
+                }
+
+                public Core.x5E Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x5F : Inner
+            {
+                public x5F(Core.x5F value)
+                {
+                    Value = value;
+                }
+
+                public Core.x5F Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x60 : Inner
+            {
+                public x60(Core.x60 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x60 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x61 : Inner
+            {
+                public x61(Core.x61 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x61 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x62 : Inner
+            {
+                public x62(Core.x62 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x62 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x63 : Inner
+            {
+                public x63(Core.x63 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x63 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x64 : Inner
+            {
+                public x64(Core.x64 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x64 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x65 : Inner
+            {
+                public x65(Core.x65 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x65 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x66 : Inner
+            {
+                public x66(Core.x66 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x66 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x67 : Inner
+            {
+                public x67(Core.x67 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x67 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x68 : Inner
+            {
+                public x68(Core.x68 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x68 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x69 : Inner
+            {
+                public x69(Core.x69 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x69 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x6A : Inner
+            {
+                public x6A(Core.x6A value)
+                {
+                    Value = value;
+                }
+
+                public Core.x6A Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x6B : Inner
+            {
+                public x6B(Core.x6B value)
+                {
+                    Value = value;
+                }
+
+                public Core.x6B Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x6C : Inner
+            {
+                public x6C(Core.x6C value)
+                {
+                    Value = value;
+                }
+
+                public Core.x6C Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x6D : Inner
+            {
+                public x6D(Core.x6D value)
+                {
+                    Value = value;
+                }
+
+                public Core.x6D Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x6E : Inner
+            {
+                public x6E(Core.x6E value)
+                {
+                    Value = value;
+                }
+
+                public Core.x6E Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x6F : Inner
+            {
+                public x6F(Core.x6F value)
+                {
+                    Value = value;
+                }
+
+                public Core.x6F Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x70 : Inner
+            {
+                public x70(Core.x70 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x70 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x71 : Inner
+            {
+                public x71(Core.x71 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x71 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x72 : Inner
+            {
+                public x72(Core.x72 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x72 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x73 : Inner
+            {
+                public x73(Core.x73 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x73 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x74 : Inner
+            {
+                public x74(Core.x74 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x74 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x75 : Inner
+            {
+                public x75(Core.x75 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x75 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x76 : Inner
+            {
+                public x76(Core.x76 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x76 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x77 : Inner
+            {
+                public x77(Core.x77 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x77 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x78 : Inner
+            {
+                public x78(Core.x78 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x78 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x79 : Inner
+            {
+                public x79(Core.x79 value)
+                {
+                    Value = value;
+                }
+
+                public Core.x79 Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x7A : Inner
+            {
+                public x7A(Core.x7A value)
+                {
+                    Value = value;
+                }
+
+                public Core.x7A Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x7B : Inner
+            {
+                public x7B(Core.x7B value)
+                {
+                    Value = value;
+                }
+
+                public Core.x7B Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x7C : Inner
+            {
+                public x7C(Core.x7C value)
+                {
+                    Value = value;
+                }
+
+                public Core.x7C Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x7D : Inner
+            {
+                public x7D(Core.x7D value)
+                {
+                    Value = value;
+                }
+
+                public Core.x7D Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class x7E : Inner
+            {
+                public x7E(Core.x7E value)
+                {
+                    Value = value;
+                }
+
+                public Core.x7E Value { get; }
+
+                public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Cnl.cs b/odata/AbnfParser/CstNodes/Cnl.cs
new file mode 100644
index 0000000000..7d0f6fc2c2
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Cnl.cs
@@ -0,0 +1,54 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+
+    public abstract class Cnl
+    {
+        private Cnl()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Cnl node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(Comment node, TContext context);
+            protected internal abstract TResult Accept(Newline node, TContext context);
+        }
+
+        public sealed class Comment : Cnl
+        {
+            public Comment(CstNodes.Comment value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.Comment Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Newline : Cnl
+        {
+            public Newline(Crlf crlf)
+            {
+                Crlf = crlf;
+            }
+
+            public Crlf Crlf { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Comment.cs b/odata/AbnfParser/CstNodes/Comment.cs
new file mode 100644
index 0000000000..2344c2d87f
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Comment.cs
@@ -0,0 +1,70 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public sealed class Comment
+    {
+        public Comment(x3B semicolon, IEnumerable<Inner> inners, Crlf crlf)
+        {
+            Semicolon = semicolon;
+            Inners = inners;
+            Crlf = crlf;
+        }
+
+        public x3B Semicolon { get; }
+        public IEnumerable<Inner> Inners { get; }
+        public Crlf Crlf { get; }
+
+        public abstract class Inner
+        {
+            private Inner()
+            {
+            }
+
+            protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+            public abstract class Visitor<TResult, TContext>
+            {
+                public TResult Visit(Inner node, TContext context)
+                {
+                    return node.Dispatch(this, context);
+                }
+
+                protected internal abstract TResult Accept(InnerWsp node, TContext context);
+                protected internal abstract TResult Accept(InnerVchar node, TContext context);
+            }
+
+            public sealed class InnerWsp : Inner
+            {
+                public InnerWsp(Wsp wsp)
+                {
+                    Wsp = wsp;
+                }
+
+                public Wsp Wsp { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class InnerVchar : Inner
+            {
+                public InnerVchar(Vchar vchar)
+                {
+                    Vchar = vchar;
+                }
+
+                public Vchar Vchar { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Concatenation.cs b/odata/AbnfParser/CstNodes/Concatenation.cs
new file mode 100644
index 0000000000..9f42d25e78
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Concatenation.cs
@@ -0,0 +1,29 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    public sealed class Concatenation
+    {
+        public Concatenation(Repetition repetition, IEnumerable<Inner> inners)
+        {
+            Repetition = repetition;
+            Inners = inners;
+        }
+
+        public Repetition Repetition { get; }
+        public IEnumerable<Inner> Inners { get; }
+
+        public sealed class Inner
+        {
+            public Inner(IEnumerable<Cwsp> cwsps, Repetition repetition)
+            {
+                //// TODO assert one or more
+                Cwsps = cwsps;
+                Repetition = repetition;
+            }
+
+            public IEnumerable<Cwsp> Cwsps { get; }
+            public Repetition Repetition { get; }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Alpha.cs b/odata/AbnfParser/CstNodes/Core/Alpha.cs
new file mode 100644
index 0000000000..3ad9b6544e
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Alpha.cs
@@ -0,0 +1,852 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public abstract class Alpha
+    {
+        private Alpha()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Alpha node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(x41 node, TContext context);
+            protected internal abstract TResult Accept(x42 node, TContext context);
+            protected internal abstract TResult Accept(x43 node, TContext context);
+            protected internal abstract TResult Accept(x44 node, TContext context);
+            protected internal abstract TResult Accept(x45 node, TContext context);
+            protected internal abstract TResult Accept(x46 node, TContext context);
+            protected internal abstract TResult Accept(x47 node, TContext context);
+            protected internal abstract TResult Accept(x48 node, TContext context);
+            protected internal abstract TResult Accept(x49 node, TContext context);
+            protected internal abstract TResult Accept(x4A node, TContext context);
+            protected internal abstract TResult Accept(x4B node, TContext context);
+            protected internal abstract TResult Accept(x4C node, TContext context);
+            protected internal abstract TResult Accept(x4D node, TContext context);
+            protected internal abstract TResult Accept(x4E node, TContext context);
+            protected internal abstract TResult Accept(x4F node, TContext context);
+            protected internal abstract TResult Accept(x50 node, TContext context);
+            protected internal abstract TResult Accept(x51 node, TContext context);
+            protected internal abstract TResult Accept(x52 node, TContext context);
+            protected internal abstract TResult Accept(x53 node, TContext context);
+            protected internal abstract TResult Accept(x54 node, TContext context);
+            protected internal abstract TResult Accept(x55 node, TContext context);
+            protected internal abstract TResult Accept(x56 node, TContext context);
+            protected internal abstract TResult Accept(x57 node, TContext context);
+            protected internal abstract TResult Accept(x58 node, TContext context);
+            protected internal abstract TResult Accept(x59 node, TContext context);
+            protected internal abstract TResult Accept(x5A node, TContext context);
+            protected internal abstract TResult Accept(x61 node, TContext context);
+            protected internal abstract TResult Accept(x62 node, TContext context);
+            protected internal abstract TResult Accept(x63 node, TContext context);
+            protected internal abstract TResult Accept(x64 node, TContext context);
+            protected internal abstract TResult Accept(x65 node, TContext context);
+            protected internal abstract TResult Accept(x66 node, TContext context);
+            protected internal abstract TResult Accept(x67 node, TContext context);
+            protected internal abstract TResult Accept(x68 node, TContext context);
+            protected internal abstract TResult Accept(x69 node, TContext context);
+            protected internal abstract TResult Accept(x6A node, TContext context);
+            protected internal abstract TResult Accept(x6B node, TContext context);
+            protected internal abstract TResult Accept(x6C node, TContext context);
+            protected internal abstract TResult Accept(x6D node, TContext context);
+            protected internal abstract TResult Accept(x6E node, TContext context);
+            protected internal abstract TResult Accept(x6F node, TContext context);
+            protected internal abstract TResult Accept(x70 node, TContext context);
+            protected internal abstract TResult Accept(x71 node, TContext context);
+            protected internal abstract TResult Accept(x72 node, TContext context);
+            protected internal abstract TResult Accept(x73 node, TContext context);
+            protected internal abstract TResult Accept(x74 node, TContext context);
+            protected internal abstract TResult Accept(x75 node, TContext context);
+            protected internal abstract TResult Accept(x76 node, TContext context);
+            protected internal abstract TResult Accept(x77 node, TContext context);
+            protected internal abstract TResult Accept(x78 node, TContext context);
+            protected internal abstract TResult Accept(x79 node, TContext context);
+            protected internal abstract TResult Accept(x7A node, TContext context);
+        }
+
+        public sealed class x41 : Alpha
+        {
+            public x41(AbnfParser.CstNodes.Core.x41 value)
+            {
+                Value = value;
+            }
+
+            public Core.x41 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x42 : Alpha
+        {
+            public x42(AbnfParser.CstNodes.Core.x42 value)
+            {
+                Value = value;
+            }
+
+            public Core.x42 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x43 : Alpha
+        {
+            public x43(AbnfParser.CstNodes.Core.x43 value)
+            {
+                Value = value;
+            }
+
+            public Core.x43 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x44 : Alpha
+        {
+            public x44(AbnfParser.CstNodes.Core.x44 value)
+            {
+                Value = value;
+            }
+
+            public Core.x44 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x45 : Alpha
+        {
+            public x45(AbnfParser.CstNodes.Core.x45 value)
+            {
+                Value = value;
+            }
+
+            public Core.x45 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x46 : Alpha
+        {
+            public x46(AbnfParser.CstNodes.Core.x46 value)
+            {
+                Value = value;
+            }
+
+            public Core.x46 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x47 : Alpha
+        {
+            public x47(AbnfParser.CstNodes.Core.x47 value)
+            {
+                Value = value;
+            }
+
+            public Core.x47 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x48 : Alpha
+        {
+            public x48(AbnfParser.CstNodes.Core.x48 value)
+            {
+                Value = value;
+            }
+
+            public Core.x48 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x49 : Alpha
+        {
+            public x49(AbnfParser.CstNodes.Core.x49 value)
+            {
+                Value = value;
+            }
+
+            public Core.x49 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4A : Alpha
+        {
+            public x4A(AbnfParser.CstNodes.Core.x4A value)
+            {
+                Value = value;
+            }
+
+            public Core.x4A Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4B : Alpha
+        {
+            public x4B(AbnfParser.CstNodes.Core.x4B value)
+            {
+                Value = value;
+            }
+
+            public Core.x4B Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4C : Alpha
+        {
+            public x4C(AbnfParser.CstNodes.Core.x4C value)
+            {
+                Value = value;
+            }
+
+            public Core.x4C Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4D : Alpha
+        {
+            public x4D(AbnfParser.CstNodes.Core.x4D value)
+            {
+                Value = value;
+            }
+
+            public Core.x4D Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4E : Alpha
+        {
+            public x4E(AbnfParser.CstNodes.Core.x4E value)
+            {
+                Value = value;
+            }
+
+            public Core.x4E Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4F : Alpha
+        {
+            public x4F(AbnfParser.CstNodes.Core.x4F value)
+            {
+                Value = value;
+            }
+
+            public Core.x4F Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x50 : Alpha
+        {
+            public x50(AbnfParser.CstNodes.Core.x50 value)
+            {
+                Value = value;
+            }
+
+            public Core.x50 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x51 : Alpha
+        {
+            public x51(AbnfParser.CstNodes.Core.x51 value)
+            {
+                Value = value;
+            }
+
+            public Core.x51 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x52 : Alpha
+        {
+            public x52(AbnfParser.CstNodes.Core.x52 value)
+            {
+                Value = value;
+            }
+
+            public Core.x52 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x53 : Alpha
+        {
+            public x53(AbnfParser.CstNodes.Core.x53 value)
+            {
+                Value = value;
+            }
+
+            public Core.x53 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x54 : Alpha
+        {
+            public x54(AbnfParser.CstNodes.Core.x54 value)
+            {
+                Value = value;
+            }
+
+            public Core.x54 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x55 : Alpha
+        {
+            public x55(AbnfParser.CstNodes.Core.x55 value)
+            {
+                Value = value;
+            }
+
+            public Core.x55 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x56 : Alpha
+        {
+            public x56(AbnfParser.CstNodes.Core.x56 value)
+            {
+                Value = value;
+            }
+
+            public Core.x56 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x57 : Alpha
+        {
+            public x57(AbnfParser.CstNodes.Core.x57 value)
+            {
+                Value = value;
+            }
+
+            public Core.x57 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x58 : Alpha
+        {
+            public x58(AbnfParser.CstNodes.Core.x58 value)
+            {
+                Value = value;
+            }
+
+            public Core.x58 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x59 : Alpha
+        {
+            public x59(AbnfParser.CstNodes.Core.x59 value)
+            {
+                Value = value;
+            }
+
+            public Core.x59 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5A : Alpha
+        {
+            public x5A(AbnfParser.CstNodes.Core.x5A value)
+            {
+                Value = value;
+            }
+
+            public Core.x5A Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x61 : Alpha
+        {
+            public x61(AbnfParser.CstNodes.Core.x61 value)
+            {
+                Value = value;
+            }
+
+            public Core.x61 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x62 : Alpha
+        {
+            public x62(AbnfParser.CstNodes.Core.x62 value)
+            {
+                Value = value;
+            }
+
+            public Core.x62 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x63 : Alpha
+        {
+            public x63(AbnfParser.CstNodes.Core.x63 value)
+            {
+                Value = value;
+            }
+
+            public Core.x63 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x64 : Alpha
+        {
+            public x64(AbnfParser.CstNodes.Core.x64 value)
+            {
+                Value = value;
+            }
+
+            public Core.x64 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x65 : Alpha
+        {
+            public x65(AbnfParser.CstNodes.Core.x65 value)
+            {
+                Value = value;
+            }
+
+            public Core.x65 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x66 : Alpha
+        {
+            public x66(AbnfParser.CstNodes.Core.x66 value)
+            {
+                Value = value;
+            }
+
+            public Core.x66 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x67 : Alpha
+        {
+            public x67(AbnfParser.CstNodes.Core.x67 value)
+            {
+                Value = value;
+            }
+
+            public Core.x67 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x68 : Alpha
+        {
+            public x68(AbnfParser.CstNodes.Core.x68 value)
+            {
+                Value = value;
+            }
+
+            public Core.x68 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x69 : Alpha
+        {
+            public x69(AbnfParser.CstNodes.Core.x69 value)
+            {
+                Value = value;
+            }
+
+            public Core.x69 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6A : Alpha
+        {
+            public x6A(AbnfParser.CstNodes.Core.x6A value)
+            {
+                Value = value;
+            }
+
+            public Core.x6A Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6B : Alpha
+        {
+            public x6B(AbnfParser.CstNodes.Core.x6B value)
+            {
+                Value = value;
+            }
+
+            public Core.x6B Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6C : Alpha
+        {
+            public x6C(AbnfParser.CstNodes.Core.x6C value)
+            {
+                Value = value;
+            }
+
+            public Core.x6C Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6D : Alpha
+        {
+            public x6D(AbnfParser.CstNodes.Core.x6D value)
+            {
+                Value = value;
+            }
+
+            public Core.x6D Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6E : Alpha
+        {
+            public x6E(AbnfParser.CstNodes.Core.x6E value)
+            {
+                Value = value;
+            }
+
+            public Core.x6E Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6F : Alpha
+        {
+            public x6F(AbnfParser.CstNodes.Core.x6F value)
+            {
+                Value = value;
+            }
+
+            public Core.x6F Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x70 : Alpha
+        {
+            public x70(AbnfParser.CstNodes.Core.x70 value)
+            {
+                Value = value;
+            }
+
+            public Core.x70 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x71 : Alpha
+        {
+            public x71(AbnfParser.CstNodes.Core.x71 value)
+            {
+                Value = value;
+            }
+
+            public Core.x71 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x72 : Alpha
+        {
+            public x72(AbnfParser.CstNodes.Core.x72 value)
+            {
+                Value = value;
+            }
+
+            public Core.x72 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x73 : Alpha
+        {
+            public x73(AbnfParser.CstNodes.Core.x73 value)
+            {
+                Value = value;
+            }
+
+            public Core.x73 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x74 : Alpha
+        {
+            public x74(AbnfParser.CstNodes.Core.x74 value)
+            {
+                Value = value;
+            }
+
+            public Core.x74 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x75 : Alpha
+        {
+            public x75(AbnfParser.CstNodes.Core.x75 value)
+            {
+                Value = value;
+            }
+
+            public Core.x75 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x76 : Alpha
+        {
+            public x76(AbnfParser.CstNodes.Core.x76 value)
+            {
+                Value = value;
+            }
+
+            public Core.x76 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x77 : Alpha
+        {
+            public x77(AbnfParser.CstNodes.Core.x77 value)
+            {
+                Value = value;
+            }
+
+            public Core.x77 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x78 : Alpha
+        {
+            public x78(AbnfParser.CstNodes.Core.x78 value)
+            {
+                Value = value;
+            }
+
+            public Core.x78 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x79 : Alpha
+        {
+            public x79(AbnfParser.CstNodes.Core.x79 value)
+            {
+                Value = value;
+            }
+
+            public Core.x79 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7A : Alpha
+        {
+            public x7A(AbnfParser.CstNodes.Core.x7A value)
+            {
+                Value = value;
+            }
+
+            public Core.x7A Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Bit.cs b/odata/AbnfParser/CstNodes/Core/Bit.cs
new file mode 100644
index 0000000000..8144fae02d
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Bit.cs
@@ -0,0 +1,52 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public abstract class Bit
+    {
+        private Bit()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Bit node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(Zero node, TContext context);
+            protected internal abstract TResult Accept(One node, TContext context);
+        }
+
+        public sealed class Zero : Bit
+        {
+            public Zero(x30 value)
+            {
+                Value = value;
+            }
+
+            public x30 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class One : Bit
+        {
+            public One(x31 value)
+            {
+                Value = value;
+            }
+
+            public x31 Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Char.cs b/odata/AbnfParser/CstNodes/Core/Char.cs
new file mode 100644
index 0000000000..3a66a48d18
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Char.cs
@@ -0,0 +1,3326 @@
+namespace AbnfParser.CstNodes.Core
+{
+    //// TODO finish the core rules
+
+    public abstract class Char
+    {
+        private Char()
+        {
+        }
+
+        public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Char node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(x01 node, TContext context);
+            protected internal abstract TResult Accept(x02 node, TContext context);
+            protected internal abstract TResult Accept(x03 node, TContext context);
+            protected internal abstract TResult Accept(x04 node, TContext context);
+            protected internal abstract TResult Accept(x05 node, TContext context);
+            protected internal abstract TResult Accept(x06 node, TContext context);
+            protected internal abstract TResult Accept(x07 node, TContext context);
+            protected internal abstract TResult Accept(x08 node, TContext context);
+            protected internal abstract TResult Accept(x09 node, TContext context);
+            protected internal abstract TResult Accept(x0A node, TContext context);
+            protected internal abstract TResult Accept(x0B node, TContext context);
+            protected internal abstract TResult Accept(x0C node, TContext context);
+            protected internal abstract TResult Accept(x0D node, TContext context);
+            protected internal abstract TResult Accept(x0E node, TContext context);
+            protected internal abstract TResult Accept(x0F node, TContext context);
+            protected internal abstract TResult Accept(x10 node, TContext context);
+            protected internal abstract TResult Accept(x11 node, TContext context);
+            protected internal abstract TResult Accept(x12 node, TContext context);
+            protected internal abstract TResult Accept(x13 node, TContext context);
+            protected internal abstract TResult Accept(x14 node, TContext context);
+            protected internal abstract TResult Accept(x15 node, TContext context);
+            protected internal abstract TResult Accept(x16 node, TContext context);
+            protected internal abstract TResult Accept(x17 node, TContext context);
+            protected internal abstract TResult Accept(x18 node, TContext context);
+            protected internal abstract TResult Accept(x19 node, TContext context);
+            protected internal abstract TResult Accept(x1A node, TContext context);
+            protected internal abstract TResult Accept(x1B node, TContext context);
+            protected internal abstract TResult Accept(x1C node, TContext context);
+            protected internal abstract TResult Accept(x1D node, TContext context);
+            protected internal abstract TResult Accept(x1E node, TContext context);
+            protected internal abstract TResult Accept(x1F node, TContext context);
+            protected internal abstract TResult Accept(x20 node, TContext context);
+            protected internal abstract TResult Accept(x21 node, TContext context);
+            protected internal abstract TResult Accept(x22 node, TContext context);
+            protected internal abstract TResult Accept(x23 node, TContext context);
+            protected internal abstract TResult Accept(x24 node, TContext context);
+            protected internal abstract TResult Accept(x25 node, TContext context);
+            protected internal abstract TResult Accept(x26 node, TContext context);
+            protected internal abstract TResult Accept(x27 node, TContext context);
+            protected internal abstract TResult Accept(x28 node, TContext context);
+            protected internal abstract TResult Accept(x29 node, TContext context);
+            protected internal abstract TResult Accept(x2A node, TContext context);
+            protected internal abstract TResult Accept(x2B node, TContext context);
+            protected internal abstract TResult Accept(x2C node, TContext context);
+            protected internal abstract TResult Accept(x2D node, TContext context);
+            protected internal abstract TResult Accept(x2E node, TContext context);
+            protected internal abstract TResult Accept(x2F node, TContext context);
+            protected internal abstract TResult Accept(x30 node, TContext context);
+            protected internal abstract TResult Accept(x31 node, TContext context);
+            protected internal abstract TResult Accept(x32 node, TContext context);
+            protected internal abstract TResult Accept(x33 node, TContext context);
+            protected internal abstract TResult Accept(x34 node, TContext context);
+            protected internal abstract TResult Accept(x35 node, TContext context);
+            protected internal abstract TResult Accept(x36 node, TContext context);
+            protected internal abstract TResult Accept(x37 node, TContext context);
+            protected internal abstract TResult Accept(x38 node, TContext context);
+            protected internal abstract TResult Accept(x39 node, TContext context);
+            protected internal abstract TResult Accept(x3A node, TContext context);
+            protected internal abstract TResult Accept(x3B node, TContext context);
+            protected internal abstract TResult Accept(x3C node, TContext context);
+            protected internal abstract TResult Accept(x3D node, TContext context);
+            protected internal abstract TResult Accept(x3E node, TContext context);
+            protected internal abstract TResult Accept(x3F node, TContext context);
+            protected internal abstract TResult Accept(x40 node, TContext context);
+            protected internal abstract TResult Accept(x41 node, TContext context);
+            protected internal abstract TResult Accept(x42 node, TContext context);
+            protected internal abstract TResult Accept(x43 node, TContext context);
+            protected internal abstract TResult Accept(x44 node, TContext context);
+            protected internal abstract TResult Accept(x45 node, TContext context);
+            protected internal abstract TResult Accept(x46 node, TContext context);
+            protected internal abstract TResult Accept(x47 node, TContext context);
+            protected internal abstract TResult Accept(x48 node, TContext context);
+            protected internal abstract TResult Accept(x49 node, TContext context);
+            protected internal abstract TResult Accept(x4A node, TContext context);
+            protected internal abstract TResult Accept(x4B node, TContext context);
+            protected internal abstract TResult Accept(x4C node, TContext context);
+            protected internal abstract TResult Accept(x4D node, TContext context);
+            protected internal abstract TResult Accept(x4E node, TContext context);
+            protected internal abstract TResult Accept(x4F node, TContext context);
+            protected internal abstract TResult Accept(x50 node, TContext context);
+            protected internal abstract TResult Accept(x51 node, TContext context);
+            protected internal abstract TResult Accept(x52 node, TContext context);
+            protected internal abstract TResult Accept(x53 node, TContext context);
+            protected internal abstract TResult Accept(x54 node, TContext context);
+            protected internal abstract TResult Accept(x55 node, TContext context);
+            protected internal abstract TResult Accept(x56 node, TContext context);
+            protected internal abstract TResult Accept(x57 node, TContext context);
+            protected internal abstract TResult Accept(x58 node, TContext context);
+            protected internal abstract TResult Accept(x59 node, TContext context);
+            protected internal abstract TResult Accept(x5A node, TContext context);
+            protected internal abstract TResult Accept(x5B node, TContext context);
+            protected internal abstract TResult Accept(x5C node, TContext context);
+            protected internal abstract TResult Accept(x5D node, TContext context);
+            protected internal abstract TResult Accept(x5E node, TContext context);
+            protected internal abstract TResult Accept(x5F node, TContext context);
+            protected internal abstract TResult Accept(x60 node, TContext context);
+            protected internal abstract TResult Accept(x61 node, TContext context);
+            protected internal abstract TResult Accept(x62 node, TContext context);
+            protected internal abstract TResult Accept(x63 node, TContext context);
+            protected internal abstract TResult Accept(x64 node, TContext context);
+            protected internal abstract TResult Accept(x65 node, TContext context);
+            protected internal abstract TResult Accept(x66 node, TContext context);
+            protected internal abstract TResult Accept(x67 node, TContext context);
+            protected internal abstract TResult Accept(x68 node, TContext context);
+            protected internal abstract TResult Accept(x69 node, TContext context);
+            protected internal abstract TResult Accept(x6A node, TContext context);
+            protected internal abstract TResult Accept(x6B node, TContext context);
+            protected internal abstract TResult Accept(x6C node, TContext context);
+            protected internal abstract TResult Accept(x6D node, TContext context);
+            protected internal abstract TResult Accept(x6E node, TContext context);
+            protected internal abstract TResult Accept(x6F node, TContext context);
+            protected internal abstract TResult Accept(x70 node, TContext context);
+            protected internal abstract TResult Accept(x71 node, TContext context);
+            protected internal abstract TResult Accept(x72 node, TContext context);
+            protected internal abstract TResult Accept(x73 node, TContext context);
+            protected internal abstract TResult Accept(x74 node, TContext context);
+            protected internal abstract TResult Accept(x75 node, TContext context);
+            protected internal abstract TResult Accept(x76 node, TContext context);
+            protected internal abstract TResult Accept(x77 node, TContext context);
+            protected internal abstract TResult Accept(x78 node, TContext context);
+            protected internal abstract TResult Accept(x79 node, TContext context);
+            protected internal abstract TResult Accept(x7A node, TContext context);
+            protected internal abstract TResult Accept(x7B node, TContext context);
+            protected internal abstract TResult Accept(x7C node, TContext context);
+            protected internal abstract TResult Accept(x7D node, TContext context);
+            protected internal abstract TResult Accept(x7E node, TContext context);
+            protected internal abstract TResult Accept(x7F node, TContext context);
+        }
+
+        public sealed class x01 : Char
+        {
+            public x01(Core.x01 value)
+            {
+                Value = value;
+            }
+
+            public Core.x01 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x02 : Char
+        {
+            public x02(Core.x02 value)
+            {
+                Value = value;
+            }
+
+            public Core.x02 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x03 : Char
+        {
+            public x03(Core.x03 value)
+            {
+                Value = value;
+            }
+
+            public Core.x03 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x04 : Char
+        {
+            public x04(Core.x04 value)
+            {
+                Value = value;
+            }
+
+            public Core.x04 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x05 : Char
+        {
+            public x05(Core.x05 value)
+            {
+                Value = value;
+            }
+
+            public Core.x05 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x06 : Char
+        {
+            public x06(Core.x06 value)
+            {
+                Value = value;
+            }
+
+            public Core.x06 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x07 : Char
+        {
+            public x07(Core.x07 value)
+            {
+                Value = value;
+            }
+
+            public Core.x07 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x08 : Char
+        {
+            public x08(Core.x08 value)
+            {
+                Value = value;
+            }
+
+            public Core.x08 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x09 : Char
+        {
+            public x09(Core.x09 value)
+            {
+                Value = value;
+            }
+
+            public Core.x09 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x0A : Char
+        {
+            public x0A(Core.x0A value)
+            {
+                Value = value;
+            }
+
+            public Core.x0A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x0B : Char
+        {
+            public x0B(Core.x0B value)
+            {
+                Value = value;
+            }
+
+            public Core.x0B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x0C : Char
+        {
+            public x0C(Core.x0C value)
+            {
+                Value = value;
+            }
+
+            public Core.x0C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x0D : Char
+        {
+            public x0D(Core.x0D value)
+            {
+                Value = value;
+            }
+
+            public Core.x0D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x0E : Char
+        {
+            public x0E(Core.x0E value)
+            {
+                Value = value;
+            }
+
+            public Core.x0E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x0F : Char
+        {
+            public x0F(Core.x0F value)
+            {
+                Value = value;
+            }
+
+            public Core.x0F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x10 : Char
+        {
+            public x10(Core.x10 value)
+            {
+                Value = value;
+            }
+
+            public Core.x10 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x11 : Char
+        {
+            public x11(Core.x11 value)
+            {
+                Value = value;
+            }
+
+            public Core.x11 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x12 : Char
+        {
+            public x12(Core.x12 value)
+            {
+                Value = value;
+            }
+
+            public Core.x12 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x13 : Char
+        {
+            public x13(Core.x13 value)
+            {
+                Value = value;
+            }
+
+            public Core.x13 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x14 : Char
+        {
+            public x14(Core.x14 value)
+            {
+                Value = value;
+            }
+
+            public Core.x14 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x15 : Char
+        {
+            public x15(Core.x15 value)
+            {
+                Value = value;
+            }
+
+            public Core.x15 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x16 : Char
+        {
+            public x16(Core.x16 value)
+            {
+                Value = value;
+            }
+
+            public Core.x16 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x17 : Char
+        {
+            public x17(Core.x17 value)
+            {
+                Value = value;
+            }
+
+            public Core.x17 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x18 : Char
+        {
+            public x18(Core.x18 value)
+            {
+                Value = value;
+            }
+
+            public Core.x18 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x19 : Char
+        {
+            public x19(Core.x19 value)
+            {
+                Value = value;
+            }
+
+            public Core.x19 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x1A : Char
+        {
+            public x1A(Core.x1A value)
+            {
+                Value = value;
+            }
+
+            public Core.x1A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x1B : Char
+        {
+            public x1B(Core.x1B value)
+            {
+                Value = value;
+            }
+
+            public Core.x1B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x1C : Char
+        {
+            public x1C(Core.x1C value)
+            {
+                Value = value;
+            }
+
+            public Core.x1C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x1D : Char
+        {
+            public x1D(Core.x1D value)
+            {
+                Value = value;
+            }
+
+            public Core.x1D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x1E : Char
+        {
+            public x1E(Core.x1E value)
+            {
+                Value = value;
+            }
+
+            public Core.x1E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x1F : Char
+        {
+            public x1F(Core.x1F value)
+            {
+                Value = value;
+            }
+
+            public Core.x1F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x20 : Char
+        {
+            public x20(Core.x20 value)
+            {
+                Value = value;
+            }
+
+            public Core.x20 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x21 : Char
+        {
+            public x21(Core.x21 value)
+            {
+                Value = value;
+            }
+
+            public Core.x21 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x22 : Char
+        {
+            public x22(Core.x22 value)
+            {
+                Value = value;
+            }
+
+            public Core.x22 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x23 : Char
+        {
+            public x23(Core.x23 value)
+            {
+                Value = value;
+            }
+
+            public Core.x23 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x24 : Char
+        {
+            public x24(Core.x24 value)
+            {
+                Value = value;
+            }
+
+            public Core.x24 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x25 : Char
+        {
+            public x25(Core.x25 value)
+            {
+                Value = value;
+            }
+
+            public Core.x25 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x26 : Char
+        {
+            public x26(Core.x26 value)
+            {
+                Value = value;
+            }
+
+            public Core.x26 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x27 : Char
+        {
+            public x27(Core.x27 value)
+            {
+                Value = value;
+            }
+
+            public Core.x27 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x28 : Char
+        {
+            public x28(Core.x28 value)
+            {
+                Value = value;
+            }
+
+            public Core.x28 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x29 : Char
+        {
+            public x29(Core.x29 value)
+            {
+                Value = value;
+            }
+
+            public Core.x29 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x2A : Char
+        {
+            public x2A(Core.x2A value)
+            {
+                Value = value;
+            }
+
+            public Core.x2A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x2B : Char
+        {
+            public x2B(Core.x2B value)
+            {
+                Value = value;
+            }
+
+            public Core.x2B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x2C : Char
+        {
+            public x2C(Core.x2C value)
+            {
+                Value = value;
+            }
+
+            public Core.x2C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x2D : Char
+        {
+            public x2D(Core.x2D value)
+            {
+                Value = value;
+            }
+
+            public Core.x2D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x2E : Char
+        {
+            public x2E(Core.x2E value)
+            {
+                Value = value;
+            }
+
+            public Core.x2E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x2F : Char
+        {
+            public x2F(Core.x2F value)
+            {
+                Value = value;
+            }
+
+            public Core.x2F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x30 : Char
+        {
+            public x30(Core.x30 value)
+            {
+                Value = value;
+            }
+
+            public Core.x30 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x31 : Char
+        {
+            public x31(Core.x31 value)
+            {
+                Value = value;
+            }
+
+            public Core.x31 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x32 : Char
+        {
+            public x32(Core.x32 value)
+            {
+                Value = value;
+            }
+
+            public Core.x32 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x33 : Char
+        {
+            public x33(Core.x33 value)
+            {
+                Value = value;
+            }
+
+            public Core.x33 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x34 : Char
+        {
+            public x34(Core.x34 value)
+            {
+                Value = value;
+            }
+
+            public Core.x34 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x35 : Char
+        {
+            public x35(Core.x35 value)
+            {
+                Value = value;
+            }
+
+            public Core.x35 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x36 : Char
+        {
+            public x36(Core.x36 value)
+            {
+                Value = value;
+            }
+
+            public Core.x36 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x37 : Char
+        {
+            public x37(Core.x37 value)
+            {
+                Value = value;
+            }
+
+            public Core.x37 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x38 : Char
+        {
+            public x38(Core.x38 value)
+            {
+                Value = value;
+            }
+
+            public Core.x38 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x39 : Char
+        {
+            public x39(Core.x39 value)
+            {
+                Value = value;
+            }
+
+            public Core.x39 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x3A : Char
+        {
+            public x3A(Core.x3A value)
+            {
+                Value = value;
+            }
+
+            public Core.x3A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x3B : Char
+        {
+            public x3B(Core.x3B value)
+            {
+                Value = value;
+            }
+
+            public Core.x3B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x3C : Char
+        {
+            public x3C(Core.x3C value)
+            {
+                Value = value;
+            }
+
+            public Core.x3C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x3D : Char
+        {
+            public x3D(Core.x3D value)
+            {
+                Value = value;
+            }
+
+            public Core.x3D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x3E : Char
+        {
+            public x3E(Core.x3E value)
+            {
+                Value = value;
+            }
+
+            public Core.x3E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x3F : Char
+        {
+            public x3F(Core.x3F value)
+            {
+                Value = value;
+            }
+
+            public Core.x3F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x40 : Char
+        {
+            public x40(Core.x40 value)
+            {
+                Value = value;
+            }
+
+            public Core.x40 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x41 : Char
+        {
+            public x41(Core.x41 value)
+            {
+                Value = value;
+            }
+
+            public Core.x41 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x42 : Char
+        {
+            public x42(Core.x42 value)
+            {
+                Value = value;
+            }
+
+            public Core.x42 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x43 : Char
+        {
+            public x43(Core.x43 value)
+            {
+                Value = value;
+            }
+
+            public Core.x43 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x44 : Char
+        {
+            public x44(Core.x44 value)
+            {
+                Value = value;
+            }
+
+            public Core.x44 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x45 : Char
+        {
+            public x45(Core.x45 value)
+            {
+                Value = value;
+            }
+
+            public Core.x45 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x46 : Char
+        {
+            public x46(Core.x46 value)
+            {
+                Value = value;
+            }
+
+            public Core.x46 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x47 : Char
+        {
+            public x47(Core.x47 value)
+            {
+                Value = value;
+            }
+
+            public Core.x47 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x48 : Char
+        {
+            public x48(Core.x48 value)
+            {
+                Value = value;
+            }
+
+            public Core.x48 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x49 : Char
+        {
+            public x49(Core.x49 value)
+            {
+                Value = value;
+            }
+
+            public Core.x49 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x4A : Char
+        {
+            public x4A(Core.x4A value)
+            {
+                Value = value;
+            }
+
+            public Core.x4A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x4B : Char
+        {
+            public x4B(Core.x4B value)
+            {
+                Value = value;
+            }
+
+            public Core.x4B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x4C : Char
+        {
+            public x4C(Core.x4C value)
+            {
+                Value = value;
+            }
+
+            public Core.x4C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x4D : Char
+        {
+            public x4D(Core.x4D value)
+            {
+                Value = value;
+            }
+
+            public Core.x4D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x4E : Char
+        {
+            public x4E(Core.x4E value)
+            {
+                Value = value;
+            }
+
+            public Core.x4E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x4F : Char
+        {
+            public x4F(Core.x4F value)
+            {
+                Value = value;
+            }
+
+            public Core.x4F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x50 : Char
+        {
+            public x50(Core.x50 value)
+            {
+                Value = value;
+            }
+
+            public Core.x50 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x51 : Char
+        {
+            public x51(Core.x51 value)
+            {
+                Value = value;
+            }
+
+            public Core.x51 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x52 : Char
+        {
+            public x52(Core.x52 value)
+            {
+                Value = value;
+            }
+
+            public Core.x52 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x53 : Char
+        {
+            public x53(Core.x53 value)
+            {
+                Value = value;
+            }
+
+            public Core.x53 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x54 : Char
+        {
+            public x54(Core.x54 value)
+            {
+                Value = value;
+            }
+
+            public Core.x54 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x55 : Char
+        {
+            public x55(Core.x55 value)
+            {
+                Value = value;
+            }
+
+            public Core.x55 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x56 : Char
+        {
+            public x56(Core.x56 value)
+            {
+                Value = value;
+            }
+
+            public Core.x56 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x57 : Char
+        {
+            public x57(Core.x57 value)
+            {
+                Value = value;
+            }
+
+            public Core.x57 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x58 : Char
+        {
+            public x58(Core.x58 value)
+            {
+                Value = value;
+            }
+
+            public Core.x58 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x59 : Char
+        {
+            public x59(Core.x59 value)
+            {
+                Value = value;
+            }
+
+            public Core.x59 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x5A : Char
+        {
+            public x5A(Core.x5A value)
+            {
+                Value = value;
+            }
+
+            public Core.x5A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x5B : Char
+        {
+            public x5B(Core.x5B value)
+            {
+                Value = value;
+            }
+
+            public Core.x5B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x5C : Char
+        {
+            public x5C(Core.x5C value)
+            {
+                Value = value;
+            }
+
+            public Core.x5C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x5D : Char
+        {
+            public x5D(Core.x5D value)
+            {
+                Value = value;
+            }
+
+            public Core.x5D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x5E : Char
+        {
+            public x5E(Core.x5E value)
+            {
+                Value = value;
+            }
+
+            public Core.x5E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x5F : Char
+        {
+            public x5F(Core.x5F value)
+            {
+                Value = value;
+            }
+
+            public Core.x5F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x60 : Char
+        {
+            public x60(Core.x60 value)
+            {
+                Value = value;
+            }
+
+            public Core.x60 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x61 : Char
+        {
+            public x61(Core.x61 value)
+            {
+                Value = value;
+            }
+
+            public Core.x61 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x62 : Char
+        {
+            public x62(Core.x62 value)
+            {
+                Value = value;
+            }
+
+            public Core.x62 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x63 : Char
+        {
+            public x63(Core.x63 value)
+            {
+                Value = value;
+            }
+
+            public Core.x63 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x64 : Char
+        {
+            public x64(Core.x64 value)
+            {
+                Value = value;
+            }
+
+            public Core.x64 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x65 : Char
+        {
+            public x65(Core.x65 value)
+            {
+                Value = value;
+            }
+
+            public Core.x65 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x66 : Char
+        {
+            public x66(Core.x66 value)
+            {
+                Value = value;
+            }
+
+            public Core.x66 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x67 : Char
+        {
+            public x67(Core.x67 value)
+            {
+                Value = value;
+            }
+
+            public Core.x67 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x68 : Char
+        {
+            public x68(Core.x68 value)
+            {
+                Value = value;
+            }
+
+            public Core.x68 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x69 : Char
+        {
+            public x69(Core.x69 value)
+            {
+                Value = value;
+            }
+
+            public Core.x69 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x6A : Char
+        {
+            public x6A(Core.x6A value)
+            {
+                Value = value;
+            }
+
+            public Core.x6A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x6B : Char
+        {
+            public x6B(Core.x6B value)
+            {
+                Value = value;
+            }
+
+            public Core.x6B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x6C : Char
+        {
+            public x6C(Core.x6C value)
+            {
+                Value = value;
+            }
+
+            public Core.x6C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x6D : Char
+        {
+            public x6D(Core.x6D value)
+            {
+                Value = value;
+            }
+
+            public Core.x6D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x6E : Char
+        {
+            public x6E(Core.x6E value)
+            {
+                Value = value;
+            }
+
+            public Core.x6E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x6F : Char
+        {
+            public x6F(Core.x6F value)
+            {
+                Value = value;
+            }
+
+            public Core.x6F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x70 : Char
+        {
+            public x70(Core.x70 value)
+            {
+                Value = value;
+            }
+
+            public Core.x70 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x71 : Char
+        {
+            public x71(Core.x71 value)
+            {
+                Value = value;
+            }
+
+            public Core.x71 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x72 : Char
+        {
+            public x72(Core.x72 value)
+            {
+                Value = value;
+            }
+
+            public Core.x72 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x73 : Char
+        {
+            public x73(Core.x73 value)
+            {
+                Value = value;
+            }
+
+            public Core.x73 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x74 : Char
+        {
+            public x74(Core.x74 value)
+            {
+                Value = value;
+            }
+
+            public Core.x74 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x75 : Char
+        {
+            public x75(Core.x75 value)
+            {
+                Value = value;
+            }
+
+            public Core.x75 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x76 : Char
+        {
+            public x76(Core.x76 value)
+            {
+                Value = value;
+            }
+
+            public Core.x76 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x77 : Char
+        {
+            public x77(Core.x77 value)
+            {
+                Value = value;
+            }
+
+            public Core.x77 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x78 : Char
+        {
+            public x78(Core.x78 value)
+            {
+                Value = value;
+            }
+
+            public Core.x78 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x79 : Char
+        {
+            public x79(Core.x79 value)
+            {
+                Value = value;
+            }
+
+            public Core.x79 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x7A : Char
+        {
+            public x7A(Core.x7A value)
+            {
+                Value = value;
+            }
+
+            public Core.x7A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x7B : Char
+        {
+            public x7B(Core.x7B value)
+            {
+                Value = value;
+            }
+
+            public Core.x7B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x7C : Char
+        {
+            public x7C(Core.x7C value)
+            {
+                Value = value;
+            }
+
+            public Core.x7C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x7D : Char
+        {
+            public x7D(Core.x7D value)
+            {
+                Value = value;
+            }
+
+            public Core.x7D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x7E : Char
+        {
+            public x7E(Core.x7E value)
+            {
+                Value = value;
+            }
+
+            public Core.x7E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x7F : Char
+        {
+            public x7F(Core.x7F value)
+            {
+                Value = value;
+            }
+
+            public Core.x7F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+    }
+
+    public sealed class x01
+    {
+        private x01()
+        {
+        }
+
+        public static x01 Instance { get; } = new x01();
+    }
+
+    public sealed class x02
+    {
+        private x02()
+        {
+        }
+
+        public static x02 Instance { get; } = new x02();
+    }
+
+    public sealed class x03
+    {
+        private x03()
+        {
+        }
+
+        public static x03 Instance { get; } = new x03();
+    }
+
+    public sealed class x04
+    {
+        private x04()
+        {
+        }
+
+        public static x04 Instance { get; } = new x04();
+    }
+
+    public sealed class x05
+    {
+        private x05()
+        {
+        }
+
+        public static x05 Instance { get; } = new x05();
+    }
+
+    public sealed class x06
+    {
+        private x06()
+        {
+        }
+
+        public static x06 Instance { get; } = new x06();
+    }
+
+    public sealed class x07
+    {
+        private x07()
+        {
+        }
+
+        public static x07 Instance { get; } = new x07();
+    }
+
+    public sealed class x08
+    {
+        private x08()
+        {
+        }
+
+        public static x08 Instance { get; } = new x08();
+    }
+
+    public sealed class x09
+    {
+        private x09()
+        {
+        }
+
+        public static x09 Instance { get; } = new x09();
+    }
+
+    public sealed class x0A
+    {
+        private x0A()
+        {
+        }
+
+        public static x0A Instance { get; } = new x0A();
+    }
+
+    public sealed class x0B
+    {
+        private x0B()
+        {
+        }
+
+        public static x0B Instance { get; } = new x0B();
+    }
+
+    public sealed class x0C
+    {
+        private x0C()
+        {
+        }
+
+        public static x0C Instance { get; } = new x0C();
+    }
+
+    public sealed class x0D
+    {
+        private x0D()
+        {
+        }
+
+        public static x0D Instance { get; } = new x0D();
+    }
+
+    public sealed class x0E
+    {
+        private x0E()
+        {
+        }
+
+        public static x0E Instance { get; } = new x0E();
+    }
+
+    public sealed class x0F
+    {
+        private x0F()
+        {
+        }
+
+        public static x0F Instance { get; } = new x0F();
+    }
+
+    public sealed class x10
+    {
+        private x10()
+        {
+        }
+
+        public static x10 Instance { get; } = new x10();
+    }
+
+    public sealed class x11
+    {
+        private x11()
+        {
+        }
+
+        public static x11 Instance { get; } = new x11();
+    }
+
+    public sealed class x12
+    {
+        private x12()
+        {
+        }
+
+        public static x12 Instance { get; } = new x12();
+    }
+
+    public sealed class x13
+    {
+        private x13()
+        {
+        }
+
+        public static x13 Instance { get; } = new x13();
+    }
+
+    public sealed class x14
+    {
+        private x14()
+        {
+        }
+
+        public static x14 Instance { get; } = new x14();
+    }
+
+    public sealed class x15
+    {
+        private x15()
+        {
+        }
+
+        public static x15 Instance { get; } = new x15();
+    }
+
+    public sealed class x16
+    {
+        private x16()
+        {
+        }
+
+        public static x16 Instance { get; } = new x16();
+    }
+
+    public sealed class x17
+    {
+        private x17()
+        {
+        }
+
+        public static x17 Instance { get; } = new x17();
+    }
+
+    public sealed class x18
+    {
+        private x18()
+        {
+        }
+
+        public static x18 Instance { get; } = new x18();
+    }
+
+    public sealed class x19
+    {
+        private x19()
+        {
+        }
+
+        public static x19 Instance { get; } = new x19();
+    }
+
+    public sealed class x1A
+    {
+        private x1A()
+        {
+        }
+
+        public static x1A Instance { get; } = new x1A();
+    }
+
+    public sealed class x1B
+    {
+        private x1B()
+        {
+        }
+
+        public static x1B Instance { get; } = new x1B();
+    }
+
+    public sealed class x1C
+    {
+        private x1C()
+        {
+        }
+
+        public static x1C Instance { get; } = new x1C();
+    }
+
+    public sealed class x1D
+    {
+        private x1D()
+        {
+        }
+
+        public static x1D Instance { get; } = new x1D();
+    }
+
+    public sealed class x1E
+    {
+        private x1E()
+        {
+        }
+
+        public static x1E Instance { get; } = new x1E();
+    }
+
+    public sealed class x1F
+    {
+        private x1F()
+        {
+        }
+
+        public static x1F Instance { get; } = new x1F();
+    }
+
+    public sealed class x20
+    {
+        private x20()
+        {
+        }
+
+        public static x20 Instance { get; } = new x20();
+    }
+
+    public sealed class x21
+    {
+        private x21()
+        {
+        }
+
+        public static x21 Instance { get; } = new x21();
+    }
+
+    public sealed class x22
+    {
+        private x22()
+        {
+        }
+
+        public static x22 Instance { get; } = new x22();
+    }
+
+    public sealed class x23
+    {
+        private x23()
+        {
+        }
+
+        public static x23 Instance { get; } = new x23();
+    }
+
+    public sealed class x24
+    {
+        private x24()
+        {
+        }
+
+        public static x24 Instance { get; } = new x24();
+    }
+
+    public sealed class x25
+    {
+        private x25()
+        {
+        }
+
+        public static x25 Instance { get; } = new x25();
+    }
+
+    public sealed class x26
+    {
+        private x26()
+        {
+        }
+
+        public static x26 Instance { get; } = new x26();
+    }
+
+    public sealed class x27
+    {
+        private x27()
+        {
+        }
+
+        public static x27 Instance { get; } = new x27();
+    }
+
+    public sealed class x28
+    {
+        private x28()
+        {
+        }
+
+        public static x28 Instance { get; } = new x28();
+    }
+
+    public sealed class x29
+    {
+        private x29()
+        {
+        }
+
+        public static x29 Instance { get; } = new x29();
+    }
+
+    public sealed class x2A
+    {
+        private x2A()
+        {
+        }
+
+        public static x2A Instance { get; } = new x2A();
+    }
+
+    public sealed class x2B
+    {
+        private x2B()
+        {
+        }
+
+        public static x2B Instance { get; } = new x2B();
+    }
+
+    public sealed class x2C
+    {
+        private x2C()
+        {
+        }
+
+        public static x2C Instance { get; } = new x2C();
+    }
+
+    public sealed class x2D
+    {
+        private x2D()
+        {
+        }
+
+        public static x2D Instance { get; } = new x2D();
+    }
+
+    public sealed class x2E
+    {
+        private x2E()
+        {
+        }
+
+        public static x2E Instance { get; } = new x2E();
+    }
+
+    public sealed class x2F
+    {
+        private x2F()
+        {
+        }
+
+        public static x2F Instance { get; } = new x2F();
+    }
+
+    public sealed class x30
+    {
+        private x30()
+        {
+        }
+
+        public static x30 Instance { get; } = new x30();
+    }
+
+    public sealed class x31
+    {
+        private x31()
+        {
+        }
+
+        public static x31 Instance { get; } = new x31();
+    }
+
+    public sealed class x32
+    {
+        private x32()
+        {
+        }
+
+        public static x32 Instance { get; } = new x32();
+    }
+
+    public sealed class x33
+    {
+        private x33()
+        {
+        }
+
+        public static x33 Instance { get; } = new x33();
+    }
+
+    public sealed class x34
+    {
+        private x34()
+        {
+        }
+
+        public static x34 Instance { get; } = new x34();
+    }
+
+    public sealed class x35
+    {
+        private x35()
+        {
+        }
+
+        public static x35 Instance { get; } = new x35();
+    }
+
+    public sealed class x36
+    {
+        private x36()
+        {
+        }
+
+        public static x36 Instance { get; } = new x36();
+    }
+
+    public sealed class x37
+    {
+        private x37()
+        {
+        }
+
+        public static x37 Instance { get; } = new x37();
+    }
+
+    public sealed class x38
+    {
+        private x38()
+        {
+        }
+
+        public static x38 Instance { get; } = new x38();
+    }
+
+    public sealed class x39
+    {
+        private x39()
+        {
+        }
+
+        public static x39 Instance { get; } = new x39();
+    }
+
+    public sealed class x3A
+    {
+        private x3A()
+        {
+        }
+
+        public static x3A Instance { get; } = new x3A();
+    }
+
+    public sealed class x3B
+    {
+        private x3B()
+        {
+        }
+
+        public static x3B Instance { get; } = new x3B();
+    }
+
+    public sealed class x3C
+    {
+        private x3C()
+        {
+        }
+
+        public static x3C Instance { get; } = new x3C();
+    }
+
+    public sealed class x3D
+    {
+        private x3D()
+        {
+        }
+
+        public static x3D Instance { get; } = new x3D();
+    }
+
+    public sealed class x3E
+    {
+        private x3E()
+        {
+        }
+
+        public static x3E Instance { get; } = new x3E();
+    }
+
+    public sealed class x3F
+    {
+        private x3F()
+        {
+        }
+
+        public static x3F Instance { get; } = new x3F();
+    }
+
+    public sealed class x40
+    {
+        private x40()
+        {
+        }
+
+        public static x40 Instance { get; } = new x40();
+    }
+
+    public sealed class x41
+    {
+        private x41()
+        {
+        }
+
+        public static x41 Instance { get; } = new x41();
+    }
+
+    public sealed class x42
+    {
+        private x42()
+        {
+        }
+
+        public static x42 Instance { get; } = new x42();
+    }
+
+    public sealed class x43
+    {
+        private x43()
+        {
+        }
+
+        public static x43 Instance { get; } = new x43();
+    }
+
+    public sealed class x44
+    {
+        private x44()
+        {
+        }
+
+        public static x44 Instance { get; } = new x44();
+    }
+
+    public sealed class x45
+    {
+        private x45()
+        {
+        }
+
+        public static x45 Instance { get; } = new x45();
+    }
+
+    public sealed class x46
+    {
+        private x46()
+        {
+        }
+
+        public static x46 Instance { get; } = new x46();
+    }
+
+    public sealed class x47
+    {
+        private x47()
+        {
+        }
+
+        public static x47 Instance { get; } = new x47();
+    }
+
+    public sealed class x48
+    {
+        private x48()
+        {
+        }
+
+        public static x48 Instance { get; } = new x48();
+    }
+
+    public sealed class x49
+    {
+        private x49()
+        {
+        }
+
+        public static x49 Instance { get; } = new x49();
+    }
+
+    public sealed class x4A
+    {
+        private x4A()
+        {
+        }
+
+        public static x4A Instance { get; } = new x4A();
+    }
+
+    public sealed class x4B
+    {
+        private x4B()
+        {
+        }
+
+        public static x4B Instance { get; } = new x4B();
+    }
+
+    public sealed class x4C
+    {
+        private x4C()
+        {
+        }
+
+        public static x4C Instance { get; } = new x4C();
+    }
+
+    public sealed class x4D
+    {
+        private x4D()
+        {
+        }
+
+        public static x4D Instance { get; } = new x4D();
+    }
+
+    public sealed class x4E
+    {
+        private x4E()
+        {
+        }
+
+        public static x4E Instance { get; } = new x4E();
+    }
+
+    public sealed class x4F
+    {
+        private x4F()
+        {
+        }
+
+        public static x4F Instance { get; } = new x4F();
+    }
+
+    public sealed class x50
+    {
+        private x50()
+        {
+        }
+
+        public static x50 Instance { get; } = new x50();
+    }
+
+    public sealed class x51
+    {
+        private x51()
+        {
+        }
+
+        public static x51 Instance { get; } = new x51();
+    }
+
+    public sealed class x52
+    {
+        private x52()
+        {
+        }
+
+        public static x52 Instance { get; } = new x52();
+    }
+
+    public sealed class x53
+    {
+        private x53()
+        {
+        }
+
+        public static x53 Instance { get; } = new x53();
+    }
+
+    public sealed class x54
+    {
+        private x54()
+        {
+        }
+
+        public static x54 Instance { get; } = new x54();
+    }
+
+    public sealed class x55
+    {
+        private x55()
+        {
+        }
+
+        public static x55 Instance { get; } = new x55();
+    }
+
+    public sealed class x56
+    {
+        private x56()
+        {
+        }
+
+        public static x56 Instance { get; } = new x56();
+    }
+
+    public sealed class x57
+    {
+        private x57()
+        {
+        }
+
+        public static x57 Instance { get; } = new x57();
+    }
+
+    public sealed class x58
+    {
+        private x58()
+        {
+        }
+
+        public static x58 Instance { get; } = new x58();
+    }
+
+    public sealed class x59
+    {
+        private x59()
+        {
+        }
+
+        public static x59 Instance { get; } = new x59();
+    }
+
+    public sealed class x5A
+    {
+        private x5A()
+        {
+        }
+
+        public static x5A Instance { get; } = new x5A();
+    }
+
+    public sealed class x5B
+    {
+        private x5B()
+        {
+        }
+
+        public static x5B Instance { get; } = new x5B();
+    }
+
+    public sealed class x5C
+    {
+        private x5C()
+        {
+        }
+
+        public static x5C Instance { get; } = new x5C();
+    }
+
+    public sealed class x5D
+    {
+        private x5D()
+        {
+        }
+
+        public static x5D Instance { get; } = new x5D();
+    }
+
+    public sealed class x5E
+    {
+        private x5E()
+        {
+        }
+
+        public static x5E Instance { get; } = new x5E();
+    }
+
+    public sealed class x5F
+    {
+        private x5F()
+        {
+        }
+
+        public static x5F Instance { get; } = new x5F();
+    }
+
+    public sealed class x60
+    {
+        private x60()
+        {
+        }
+
+        public static x60 Instance { get; } = new x60();
+    }
+
+    public sealed class x61
+    {
+        private x61()
+        {
+        }
+
+        public static x61 Instance { get; } = new x61();
+    }
+
+    public sealed class x62
+    {
+        private x62()
+        {
+        }
+
+        public static x62 Instance { get; } = new x62();
+    }
+
+    public sealed class x63
+    {
+        private x63()
+        {
+        }
+
+        public static x63 Instance { get; } = new x63();
+    }
+
+    public sealed class x64
+    {
+        private x64()
+        {
+        }
+
+        public static x64 Instance { get; } = new x64();
+    }
+
+    public sealed class x65
+    {
+        private x65()
+        {
+        }
+
+        public static x65 Instance { get; } = new x65();
+    }
+
+    public sealed class x66
+    {
+        private x66()
+        {
+        }
+
+        public static x66 Instance { get; } = new x66();
+    }
+
+    public sealed class x67
+    {
+        private x67()
+        {
+        }
+
+        public static x67 Instance { get; } = new x67();
+    }
+
+    public sealed class x68
+    {
+        private x68()
+        {
+        }
+
+        public static x68 Instance { get; } = new x68();
+    }
+
+    public sealed class x69
+    {
+        private x69()
+        {
+        }
+
+        public static x69 Instance { get; } = new x69();
+    }
+
+    public sealed class x6A
+    {
+        private x6A()
+        {
+        }
+
+        public static x6A Instance { get; } = new x6A();
+    }
+
+    public sealed class x6B
+    {
+        private x6B()
+        {
+        }
+
+        public static x6B Instance { get; } = new x6B();
+    }
+
+    public sealed class x6C
+    {
+        private x6C()
+        {
+        }
+
+        public static x6C Instance { get; } = new x6C();
+    }
+
+    public sealed class x6D
+    {
+        private x6D()
+        {
+        }
+
+        public static x6D Instance { get; } = new x6D();
+    }
+
+    public sealed class x6E
+    {
+        private x6E()
+        {
+        }
+
+        public static x6E Instance { get; } = new x6E();
+    }
+
+    public sealed class x6F
+    {
+        private x6F()
+        {
+        }
+
+        public static x6F Instance { get; } = new x6F();
+    }
+
+    public sealed class x70
+    {
+        private x70()
+        {
+        }
+
+        public static x70 Instance { get; } = new x70();
+    }
+
+    public sealed class x71
+    {
+        private x71()
+        {
+        }
+
+        public static x71 Instance { get; } = new x71();
+    }
+
+    public sealed class x72
+    {
+        private x72()
+        {
+        }
+
+        public static x72 Instance { get; } = new x72();
+    }
+
+    public sealed class x73
+    {
+        private x73()
+        {
+        }
+
+        public static x73 Instance { get; } = new x73();
+    }
+
+    public sealed class x74
+    {
+        private x74()
+        {
+        }
+
+        public static x74 Instance { get; } = new x74();
+    }
+
+    public sealed class x75
+    {
+        private x75()
+        {
+        }
+
+        public static x75 Instance { get; } = new x75();
+    }
+
+    public sealed class x76
+    {
+        private x76()
+        {
+        }
+
+        public static x76 Instance { get; } = new x76();
+    }
+
+    public sealed class x77
+    {
+        private x77()
+        {
+        }
+
+        public static x77 Instance { get; } = new x77();
+    }
+
+    public sealed class x78
+    {
+        private x78()
+        {
+        }
+
+        public static x78 Instance { get; } = new x78();
+    }
+
+    public sealed class x79
+    {
+        private x79()
+        {
+        }
+
+        public static x79 Instance { get; } = new x79();
+    }
+
+    public sealed class x7A
+    {
+        private x7A()
+        {
+        }
+
+        public static x7A Instance { get; } = new x7A();
+    }
+
+    public sealed class x7B
+    {
+        private x7B()
+        {
+        }
+
+        public static x7B Instance { get; } = new x7B();
+    }
+
+    public sealed class x7C
+    {
+        private x7C()
+        {
+        }
+
+        public static x7C Instance { get; } = new x7C();
+    }
+
+    public sealed class x7D
+    {
+        private x7D()
+        {
+        }
+
+        public static x7D Instance { get; } = new x7D();
+    }
+
+    public sealed class x7E
+    {
+        private x7E()
+        {
+        }
+
+        public static x7E Instance { get; } = new x7E();
+    }
+
+    public sealed class x7F
+    {
+        private x7F()
+        {
+        }
+
+        public static x7F Instance { get; } = new x7F();
+    }
+
+
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Cr.cs b/odata/AbnfParser/CstNodes/Core/Cr.cs
new file mode 100644
index 0000000000..6f990f22e8
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Cr.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public sealed class Cr
+    {
+        public Cr(x0D x0D)
+        {
+            X0D = x0D;
+        }
+
+        public x0D X0D { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Crlf.cs b/odata/AbnfParser/CstNodes/Core/Crlf.cs
new file mode 100644
index 0000000000..f272d23d60
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Crlf.cs
@@ -0,0 +1,14 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public sealed class Crlf
+    {
+        public Crlf(Cr cr, Lf lf)
+        {
+            Cr = cr;
+            Lf = lf;
+        }
+
+        public Cr Cr { get; }
+        public Lf Lf { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Digit.cs b/odata/AbnfParser/CstNodes/Core/Digit.cs
new file mode 100644
index 0000000000..cc6f93fd1d
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Digit.cs
@@ -0,0 +1,189 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public abstract class Digit
+    {
+        private Digit()
+        {
+        }
+        public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Digit node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(x30 node, TContext context);
+            protected internal abstract TResult Accept(x31 node, TContext context);
+            protected internal abstract TResult Accept(x32 node, TContext context);
+            protected internal abstract TResult Accept(x33 node, TContext context);
+            protected internal abstract TResult Accept(x34 node, TContext context);
+            protected internal abstract TResult Accept(x35 node, TContext context);
+            protected internal abstract TResult Accept(x36 node, TContext context);
+            protected internal abstract TResult Accept(x37 node, TContext context);
+            protected internal abstract TResult Accept(x38 node, TContext context);
+            protected internal abstract TResult Accept(x39 node, TContext context);
+        }
+
+        public sealed class x30 : Digit
+        {
+            public x30(Core.x30 value)
+            {
+                Value = value;
+            }
+
+            public Core.x30 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x31 : Digit
+        {
+            public x31(Core.x31 value)
+            {
+                Value = value;
+            }
+
+            public Core.x31 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x32 : Digit
+        {
+            public x32(Core.x32 value)
+            {
+                Value = value;
+            }
+
+            public Core.x32 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x33 : Digit
+        {
+            public x33(Core.x33 value)
+            {
+                Value = value;
+            }
+
+            public Core.x33 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x34 : Digit
+        {
+            public x34(Core.x34 value)
+            {
+                Value = value;
+            }
+
+            public Core.x34 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x35 : Digit
+        {
+            public x35(Core.x35 value)
+            {
+                Value = value;
+            }
+
+            public Core.x35 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x36 : Digit
+        {
+            public x36(Core.x36 value)
+            {
+                Value = value;
+            }
+
+            public Core.x36 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x37 : Digit
+        {
+            public x37(Core.x37 value)
+            {
+                Value = value;
+            }
+
+            public Core.x37 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x38 : Digit
+        {
+            public x38(Core.x38 value)
+            {
+                Value = value;
+            }
+
+            public Core.x38 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+
+        public sealed class x39 : Digit
+        {
+            public x39(Core.x39 value)
+            {
+                Value = value;
+            }
+
+            public Core.x39 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Dquote.cs b/odata/AbnfParser/CstNodes/Core/Dquote.cs
new file mode 100644
index 0000000000..dd5839e9d7
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Dquote.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public sealed class Dquote
+    {
+        public Dquote(x22 value)
+        {
+            Value = value;
+        }
+
+        public x22 Value { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/HexDig.cs b/odata/AbnfParser/CstNodes/Core/HexDig.cs
new file mode 100644
index 0000000000..45e78a3532
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/HexDig.cs
@@ -0,0 +1,132 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public abstract class HexDig
+    {
+        private HexDig()
+        {
+        }
+
+        public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(HexDig node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(Digit node, TContext context);
+            protected internal abstract TResult Accept(A node, TContext context);
+            protected internal abstract TResult Accept(B node, TContext context);
+            protected internal abstract TResult Accept(C node, TContext context);
+            protected internal abstract TResult Accept(D node, TContext context);
+            protected internal abstract TResult Accept(E node, TContext context);
+            protected internal abstract TResult Accept(F node, TContext context);
+        }
+
+        public sealed class Digit : HexDig
+        {
+            public Digit(Core.Digit value)
+            {
+                Value = value;
+            }
+
+            public Core.Digit Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class A : HexDig
+        {
+            public A(x41 value)
+            {
+                Value = value;
+            }
+
+            public x41 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class B : HexDig
+        {
+            public B(x42 value)
+            {
+                Value = value;
+            }
+
+            public x42 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class C : HexDig
+        {
+            public C(x43 value)
+            {
+                Value = value;
+            }
+
+            public x43 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class D : HexDig
+        {
+            public D(x44 value)
+            {
+                Value = value;
+            }
+
+            public x44 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class E : HexDig
+        {
+            public E(x45 value)
+            {
+                Value = value;
+            }
+
+            public x45 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class F : HexDig
+        {
+            public F(x46 value)
+            {
+                Value = value;
+            }
+
+            public x46 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Htab.cs b/odata/AbnfParser/CstNodes/Core/Htab.cs
new file mode 100644
index 0000000000..b62d484610
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Htab.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public sealed class Htab
+    {
+        public Htab(x09 value)
+        {
+            Value = value;
+        }
+
+        public x09 Value { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Lf.cs b/odata/AbnfParser/CstNodes/Core/Lf.cs
new file mode 100644
index 0000000000..899e6b3aae
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Lf.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public sealed class Lf
+    {
+        public Lf(x0A x0A)
+        {
+            X0A = x0A;
+        }
+
+        public x0A X0A { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Sp.cs b/odata/AbnfParser/CstNodes/Core/Sp.cs
new file mode 100644
index 0000000000..99d32eb8a3
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Sp.cs
@@ -0,0 +1,12 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public sealed class Sp
+    {
+        public Sp(x20 value)
+        {
+            Value = value;
+        }
+
+        public x20 Value { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Vchar.cs b/odata/AbnfParser/CstNodes/Core/Vchar.cs
new file mode 100644
index 0000000000..11dcba050c
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Vchar.cs
@@ -0,0 +1,1524 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public abstract class Vchar
+    {
+        private Vchar()
+        {
+        }
+
+        public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Vchar node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(x21 node, TContext context);
+            protected internal abstract TResult Accept(x22 node, TContext context);
+            protected internal abstract TResult Accept(x23 node, TContext context);
+            protected internal abstract TResult Accept(x24 node, TContext context);
+            protected internal abstract TResult Accept(x25 node, TContext context);
+            protected internal abstract TResult Accept(x26 node, TContext context);
+            protected internal abstract TResult Accept(x27 node, TContext context);
+            protected internal abstract TResult Accept(x28 node, TContext context);
+            protected internal abstract TResult Accept(x29 node, TContext context);
+            protected internal abstract TResult Accept(x2A node, TContext context);
+            protected internal abstract TResult Accept(x2B node, TContext context);
+            protected internal abstract TResult Accept(x2C node, TContext context);
+            protected internal abstract TResult Accept(x2D node, TContext context);
+            protected internal abstract TResult Accept(x2E node, TContext context);
+            protected internal abstract TResult Accept(x2F node, TContext context);
+            protected internal abstract TResult Accept(x30 node, TContext context);
+            protected internal abstract TResult Accept(x31 node, TContext context);
+            protected internal abstract TResult Accept(x32 node, TContext context);
+            protected internal abstract TResult Accept(x33 node, TContext context);
+            protected internal abstract TResult Accept(x34 node, TContext context);
+            protected internal abstract TResult Accept(x35 node, TContext context);
+            protected internal abstract TResult Accept(x36 node, TContext context);
+            protected internal abstract TResult Accept(x37 node, TContext context);
+            protected internal abstract TResult Accept(x38 node, TContext context);
+            protected internal abstract TResult Accept(x39 node, TContext context);
+            protected internal abstract TResult Accept(x3A node, TContext context);
+            protected internal abstract TResult Accept(x3B node, TContext context);
+            protected internal abstract TResult Accept(x3C node, TContext context);
+            protected internal abstract TResult Accept(x3D node, TContext context);
+            protected internal abstract TResult Accept(x3E node, TContext context);
+            protected internal abstract TResult Accept(x3F node, TContext context);
+            protected internal abstract TResult Accept(x40 node, TContext context);
+            protected internal abstract TResult Accept(x41 node, TContext context);
+            protected internal abstract TResult Accept(x42 node, TContext context);
+            protected internal abstract TResult Accept(x43 node, TContext context);
+            protected internal abstract TResult Accept(x44 node, TContext context);
+            protected internal abstract TResult Accept(x45 node, TContext context);
+            protected internal abstract TResult Accept(x46 node, TContext context);
+            protected internal abstract TResult Accept(x47 node, TContext context);
+            protected internal abstract TResult Accept(x48 node, TContext context);
+            protected internal abstract TResult Accept(x49 node, TContext context);
+            protected internal abstract TResult Accept(x4A node, TContext context);
+            protected internal abstract TResult Accept(x4B node, TContext context);
+            protected internal abstract TResult Accept(x4C node, TContext context);
+            protected internal abstract TResult Accept(x4D node, TContext context);
+            protected internal abstract TResult Accept(x4E node, TContext context);
+            protected internal abstract TResult Accept(x4F node, TContext context);
+            protected internal abstract TResult Accept(x50 node, TContext context);
+            protected internal abstract TResult Accept(x51 node, TContext context);
+            protected internal abstract TResult Accept(x52 node, TContext context);
+            protected internal abstract TResult Accept(x53 node, TContext context);
+            protected internal abstract TResult Accept(x54 node, TContext context);
+            protected internal abstract TResult Accept(x55 node, TContext context);
+            protected internal abstract TResult Accept(x56 node, TContext context);
+            protected internal abstract TResult Accept(x57 node, TContext context);
+            protected internal abstract TResult Accept(x58 node, TContext context);
+            protected internal abstract TResult Accept(x59 node, TContext context);
+            protected internal abstract TResult Accept(x5A node, TContext context);
+            protected internal abstract TResult Accept(x5B node, TContext context);
+            protected internal abstract TResult Accept(x5C node, TContext context);
+            protected internal abstract TResult Accept(x5D node, TContext context);
+            protected internal abstract TResult Accept(x5E node, TContext context);
+            protected internal abstract TResult Accept(x5F node, TContext context);
+            protected internal abstract TResult Accept(x60 node, TContext context);
+            protected internal abstract TResult Accept(x61 node, TContext context);
+            protected internal abstract TResult Accept(x62 node, TContext context);
+            protected internal abstract TResult Accept(x63 node, TContext context);
+            protected internal abstract TResult Accept(x64 node, TContext context);
+            protected internal abstract TResult Accept(x65 node, TContext context);
+            protected internal abstract TResult Accept(x66 node, TContext context);
+            protected internal abstract TResult Accept(x67 node, TContext context);
+            protected internal abstract TResult Accept(x68 node, TContext context);
+            protected internal abstract TResult Accept(x69 node, TContext context);
+            protected internal abstract TResult Accept(x6A node, TContext context);
+            protected internal abstract TResult Accept(x6B node, TContext context);
+            protected internal abstract TResult Accept(x6C node, TContext context);
+            protected internal abstract TResult Accept(x6D node, TContext context);
+            protected internal abstract TResult Accept(x6E node, TContext context);
+            protected internal abstract TResult Accept(x6F node, TContext context);
+            protected internal abstract TResult Accept(x70 node, TContext context);
+            protected internal abstract TResult Accept(x71 node, TContext context);
+            protected internal abstract TResult Accept(x72 node, TContext context);
+            protected internal abstract TResult Accept(x73 node, TContext context);
+            protected internal abstract TResult Accept(x74 node, TContext context);
+            protected internal abstract TResult Accept(x75 node, TContext context);
+            protected internal abstract TResult Accept(x76 node, TContext context);
+            protected internal abstract TResult Accept(x77 node, TContext context);
+            protected internal abstract TResult Accept(x78 node, TContext context);
+            protected internal abstract TResult Accept(x79 node, TContext context);
+            protected internal abstract TResult Accept(x7A node, TContext context);
+            protected internal abstract TResult Accept(x7B node, TContext context);
+            protected internal abstract TResult Accept(x7C node, TContext context);
+            protected internal abstract TResult Accept(x7D node, TContext context);
+            protected internal abstract TResult Accept(x7E node, TContext context);
+        }
+
+        public sealed class x21 : Vchar
+        {
+            public x21(Core.x21 value)
+            {
+                Value = value;
+            }
+
+            public Core.x21 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x22 : Vchar
+        {
+            public x22(Core.x22 value)
+            {
+                Value = value;
+            }
+
+            public Core.x22 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x23 : Vchar
+        {
+            public x23(Core.x23 value)
+            {
+                Value = value;
+            }
+
+            public Core.x23 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x24 : Vchar
+        {
+            public x24(Core.x24 value)
+            {
+                Value = value;
+            }
+
+            public Core.x24 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x25 : Vchar
+        {
+            public x25(Core.x25 value)
+            {
+                Value = value;
+            }
+
+            public Core.x25 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x26 : Vchar
+        {
+            public x26(Core.x26 value)
+            {
+                Value = value;
+            }
+
+            public Core.x26 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x27 : Vchar
+        {
+            public x27(Core.x27 value)
+            {
+                Value = value;
+            }
+
+            public Core.x27 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x28 : Vchar
+        {
+            public x28(Core.x28 value)
+            {
+                Value = value;
+            }
+
+            public Core.x28 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x29 : Vchar
+        {
+            public x29(Core.x29 value)
+            {
+                Value = value;
+            }
+
+            public Core.x29 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2A : Vchar
+        {
+            public x2A(Core.x2A value)
+            {
+                Value = value;
+            }
+
+            public Core.x2A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2B : Vchar
+        {
+            public x2B(Core.x2B value)
+            {
+                Value = value;
+            }
+
+            public Core.x2B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2C : Vchar
+        {
+            public x2C(Core.x2C value)
+            {
+                Value = value;
+            }
+
+            public Core.x2C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2D : Vchar
+        {
+            public x2D(Core.x2D value)
+            {
+                Value = value;
+            }
+
+            public Core.x2D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2E : Vchar
+        {
+            public x2E(Core.x2E value)
+            {
+                Value = value;
+            }
+
+            public Core.x2E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2F : Vchar
+        {
+            public x2F(Core.x2F value)
+            {
+                Value = value;
+            }
+
+            public Core.x2F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x30 : Vchar
+        {
+            public x30(Core.x30 value)
+            {
+                Value = value;
+            }
+
+            public Core.x30 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x31 : Vchar
+        {
+            public x31(Core.x31 value)
+            {
+                Value = value;
+            }
+
+            public Core.x31 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x32 : Vchar
+        {
+            public x32(Core.x32 value)
+            {
+                Value = value;
+            }
+
+            public Core.x32 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x33 : Vchar
+        {
+            public x33(Core.x33 value)
+            {
+                Value = value;
+            }
+
+            public Core.x33 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x34 : Vchar
+        {
+            public x34(Core.x34 value)
+            {
+                Value = value;
+            }
+
+            public Core.x34 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x35 : Vchar
+        {
+            public x35(Core.x35 value)
+            {
+                Value = value;
+            }
+
+            public Core.x35 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x36 : Vchar
+        {
+            public x36(Core.x36 value)
+            {
+                Value = value;
+            }
+
+            public Core.x36 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x37 : Vchar
+        {
+            public x37(Core.x37 value)
+            {
+                Value = value;
+            }
+
+            public Core.x37 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x38 : Vchar
+        {
+            public x38(Core.x38 value)
+            {
+                Value = value;
+            }
+
+            public Core.x38 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x39 : Vchar
+        {
+            public x39(Core.x39 value)
+            {
+                Value = value;
+            }
+
+            public Core.x39 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3A : Vchar
+        {
+            public x3A(Core.x3A value)
+            {
+                Value = value;
+            }
+
+            public Core.x3A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3B : Vchar
+        {
+            public x3B(Core.x3B value)
+            {
+                Value = value;
+            }
+
+            public Core.x3B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3C : Vchar
+        {
+            public x3C(Core.x3C value)
+            {
+                Value = value;
+            }
+
+            public Core.x3C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3D : Vchar
+        {
+            public x3D(Core.x3D value)
+            {
+                Value = value;
+            }
+
+            public Core.x3D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3E : Vchar
+        {
+            public x3E(Core.x3E value)
+            {
+                Value = value;
+            }
+
+            public Core.x3E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3F : Vchar
+        {
+            public x3F(Core.x3F value)
+            {
+                Value = value;
+            }
+
+            public Core.x3F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x40 : Vchar
+        {
+            public x40(Core.x40 value)
+            {
+                Value = value;
+            }
+
+            public Core.x40 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x41 : Vchar
+        {
+            public x41(Core.x41 value)
+            {
+                Value = value;
+            }
+
+            public Core.x41 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x42 : Vchar
+        {
+            public x42(Core.x42 value)
+            {
+                Value = value;
+            }
+
+            public Core.x42 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x43 : Vchar
+        {
+            public x43(Core.x43 value)
+            {
+                Value = value;
+            }
+
+            public Core.x43 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x44 : Vchar
+        {
+            public x44(Core.x44 value)
+            {
+                Value = value;
+            }
+
+            public Core.x44 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x45 : Vchar
+        {
+            public x45(Core.x45 value)
+            {
+                Value = value;
+            }
+
+            public Core.x45 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x46 : Vchar
+        {
+            public x46(Core.x46 value)
+            {
+                Value = value;
+            }
+
+            public Core.x46 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x47 : Vchar
+        {
+            public x47(Core.x47 value)
+            {
+                Value = value;
+            }
+
+            public Core.x47 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x48 : Vchar
+        {
+            public x48(Core.x48 value)
+            {
+                Value = value;
+            }
+
+            public Core.x48 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x49 : Vchar
+        {
+            public x49(Core.x49 value)
+            {
+                Value = value;
+            }
+
+            public Core.x49 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4A : Vchar
+        {
+            public x4A(Core.x4A value)
+            {
+                Value = value;
+            }
+
+            public Core.x4A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4B : Vchar
+        {
+            public x4B(Core.x4B value)
+            {
+                Value = value;
+            }
+
+            public Core.x4B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4C : Vchar
+        {
+            public x4C(Core.x4C value)
+            {
+                Value = value;
+            }
+
+            public Core.x4C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4D : Vchar
+        {
+            public x4D(Core.x4D value)
+            {
+                Value = value;
+            }
+
+            public Core.x4D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4E : Vchar
+        {
+            public x4E(Core.x4E value)
+            {
+                Value = value;
+            }
+
+            public Core.x4E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4F : Vchar
+        {
+            public x4F(Core.x4F value)
+            {
+                Value = value;
+            }
+
+            public Core.x4F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x50 : Vchar
+        {
+            public x50(Core.x50 value)
+            {
+                Value = value;
+            }
+
+            public Core.x50 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x51 : Vchar
+        {
+            public x51(Core.x51 value)
+            {
+                Value = value;
+            }
+
+            public Core.x51 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x52 : Vchar
+        {
+            public x52(Core.x52 value)
+            {
+                Value = value;
+            }
+
+            public Core.x52 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x53 : Vchar
+        {
+            public x53(Core.x53 value)
+            {
+                Value = value;
+            }
+
+            public Core.x53 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x54 : Vchar
+        {
+            public x54(Core.x54 value)
+            {
+                Value = value;
+            }
+
+            public Core.x54 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x55 : Vchar
+        {
+            public x55(Core.x55 value)
+            {
+                Value = value;
+            }
+
+            public Core.x55 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x56 : Vchar
+        {
+            public x56(Core.x56 value)
+            {
+                Value = value;
+            }
+
+            public Core.x56 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x57 : Vchar
+        {
+            public x57(Core.x57 value)
+            {
+                Value = value;
+            }
+
+            public Core.x57 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x58 : Vchar
+        {
+            public x58(Core.x58 value)
+            {
+                Value = value;
+            }
+
+            public Core.x58 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x59 : Vchar
+        {
+            public x59(Core.x59 value)
+            {
+                Value = value;
+            }
+
+            public Core.x59 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5A : Vchar
+        {
+            public x5A(Core.x5A value)
+            {
+                Value = value;
+            }
+
+            public Core.x5A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5B : Vchar
+        {
+            public x5B(Core.x5B value)
+            {
+                Value = value;
+            }
+
+            public Core.x5B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5C : Vchar
+        {
+            public x5C(Core.x5C value)
+            {
+                Value = value;
+            }
+
+            public Core.x5C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5D : Vchar
+        {
+            public x5D(Core.x5D value)
+            {
+                Value = value;
+            }
+
+            public Core.x5D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5E : Vchar
+        {
+            public x5E(Core.x5E value)
+            {
+                Value = value;
+            }
+
+            public Core.x5E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5F : Vchar
+        {
+            public x5F(Core.x5F value)
+            {
+                Value = value;
+            }
+
+            public Core.x5F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x60 : Vchar
+        {
+            public x60(Core.x60 value)
+            {
+                Value = value;
+            }
+
+            public Core.x60 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x61 : Vchar
+        {
+            public x61(Core.x61 value)
+            {
+                Value = value;
+            }
+
+            public Core.x61 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x62 : Vchar
+        {
+            public x62(Core.x62 value)
+            {
+                Value = value;
+            }
+
+            public Core.x62 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x63 : Vchar
+        {
+            public x63(Core.x63 value)
+            {
+                Value = value;
+            }
+
+            public Core.x63 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x64 : Vchar
+        {
+            public x64(Core.x64 value)
+            {
+                Value = value;
+            }
+
+            public Core.x64 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x65 : Vchar
+        {
+            public x65(Core.x65 value)
+            {
+                Value = value;
+            }
+
+            public Core.x65 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x66 : Vchar
+        {
+            public x66(Core.x66 value)
+            {
+                Value = value;
+            }
+
+            public Core.x66 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x67 : Vchar
+        {
+            public x67(Core.x67 value)
+            {
+                Value = value;
+            }
+
+            public Core.x67 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x68 : Vchar
+        {
+            public x68(Core.x68 value)
+            {
+                Value = value;
+            }
+
+            public Core.x68 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x69 : Vchar
+        {
+            public x69(Core.x69 value)
+            {
+                Value = value;
+            }
+
+            public Core.x69 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6A : Vchar
+        {
+            public x6A(Core.x6A value)
+            {
+                Value = value;
+            }
+
+            public Core.x6A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6B : Vchar
+        {
+            public x6B(Core.x6B value)
+            {
+                Value = value;
+            }
+
+            public Core.x6B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6C : Vchar
+        {
+            public x6C(Core.x6C value)
+            {
+                Value = value;
+            }
+
+            public Core.x6C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6D : Vchar
+        {
+            public x6D(Core.x6D value)
+            {
+                Value = value;
+            }
+
+            public Core.x6D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6E : Vchar
+        {
+            public x6E(Core.x6E value)
+            {
+                Value = value;
+            }
+
+            public Core.x6E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6F : Vchar
+        {
+            public x6F(Core.x6F value)
+            {
+                Value = value;
+            }
+
+            public Core.x6F Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x70 : Vchar
+        {
+            public x70(Core.x70 value)
+            {
+                Value = value;
+            }
+
+            public Core.x70 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x71 : Vchar
+        {
+            public x71(Core.x71 value)
+            {
+                Value = value;
+            }
+
+            public Core.x71 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x72 : Vchar
+        {
+            public x72(Core.x72 value)
+            {
+                Value = value;
+            }
+
+            public Core.x72 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x73 : Vchar
+        {
+            public x73(Core.x73 value)
+            {
+                Value = value;
+            }
+
+            public Core.x73 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x74 : Vchar
+        {
+            public x74(Core.x74 value)
+            {
+                Value = value;
+            }
+
+            public Core.x74 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x75 : Vchar
+        {
+            public x75(Core.x75 value)
+            {
+                Value = value;
+            }
+
+            public Core.x75 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x76 : Vchar
+        {
+            public x76(Core.x76 value)
+            {
+                Value = value;
+            }
+
+            public Core.x76 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x77 : Vchar
+        {
+            public x77(Core.x77 value)
+            {
+                Value = value;
+            }
+
+            public Core.x77 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x78 : Vchar
+        {
+            public x78(Core.x78 value)
+            {
+                Value = value;
+            }
+
+            public Core.x78 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x79 : Vchar
+        {
+            public x79(Core.x79 value)
+            {
+                Value = value;
+            }
+
+            public Core.x79 Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7A : Vchar
+        {
+            public x7A(Core.x7A value)
+            {
+                Value = value;
+            }
+
+            public Core.x7A Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7B : Vchar
+        {
+            public x7B(Core.x7B value)
+            {
+                Value = value;
+            }
+
+            public Core.x7B Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7C : Vchar
+        {
+            public x7C(Core.x7C value)
+            {
+                Value = value;
+            }
+
+            public Core.x7C Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7D : Vchar
+        {
+            public x7D(Core.x7D value)
+            {
+                Value = value;
+            }
+
+            public Core.x7D Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7E : Vchar
+        {
+            public x7E(Core.x7E value)
+            {
+                Value = value;
+            }
+
+            public Core.x7E Value { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Core/Wsp.cs b/odata/AbnfParser/CstNodes/Core/Wsp.cs
new file mode 100644
index 0000000000..88d8c15f77
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Core/Wsp.cs
@@ -0,0 +1,52 @@
+namespace AbnfParser.CstNodes.Core
+{
+    public abstract class Wsp
+    {
+        private Wsp()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Wsp node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(Space node, TContext context);
+            protected internal abstract TResult Accept(Tab node, TContext context);
+        }
+
+        public sealed class Space : Wsp
+        {
+            public Space(Sp sp)
+            {
+                Sp = sp;
+            }
+
+            public Sp Sp { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Tab : Wsp
+        {
+            public Tab(Htab htab)
+            {
+                Htab = htab;
+            }
+
+            public Htab Htab { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Cwsp.cs b/odata/AbnfParser/CstNodes/Cwsp.cs
new file mode 100644
index 0000000000..7d8f53c61d
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Cwsp.cs
@@ -0,0 +1,56 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+
+    public abstract class Cwsp
+    {
+        private Cwsp()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Cwsp node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(WspOnly node, TContext context);
+            protected internal abstract TResult Accept(CnlAndWsp node, TContext context);
+        }
+
+        public sealed class WspOnly : Cwsp
+        {
+            public WspOnly(Wsp wsp)
+            {
+                Wsp = wsp;
+            }
+
+            public Wsp Wsp { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class CnlAndWsp : Cwsp
+        {
+            public CnlAndWsp(Cnl cnl, Wsp wsp)
+            {
+                Cnl = cnl;
+                Wsp = wsp;
+            }
+
+            public Cnl Cnl { get; }
+            public Wsp Wsp { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/DecVal.cs b/odata/AbnfParser/CstNodes/DecVal.cs
new file mode 100644
index 0000000000..4138739c2d
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/DecVal.cs
@@ -0,0 +1,106 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public abstract class DecVal
+    {
+        private DecVal()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(DecVal node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(DecsOnly node, TContext context);
+            protected internal abstract TResult Accept(ConcatenatedDecs node, TContext context);
+            protected internal abstract TResult Accept(Range node, TContext context);
+        }
+
+        public sealed class DecsOnly : DecVal
+        {
+            public DecsOnly(x64 d, IEnumerable<Digit> digits)
+            {
+                D = d;
+                Digits = digits; //// TODO assert one or more
+            }
+
+            public x64 D { get; }
+            public IEnumerable<Digit> Digits { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ConcatenatedDecs : DecVal
+        {
+            public ConcatenatedDecs(x64 d, IEnumerable<Digit> digits, IEnumerable<Inner> inners)
+            {
+                D = d;
+                Digits = digits; //// TODO assert one or more
+                Inners = inners; //// TODO assert one or more
+            }
+
+            public x64 D { get; }
+            public IEnumerable<Digit> Digits { get; }
+            public IEnumerable<Inner> Inners { get; }
+
+            public sealed class Inner
+            {
+                public Inner(x2E dot, IEnumerable<Digit> digits)
+                {
+                    Dot = dot;
+                    Digits = digits; //// TODO assert one or more
+                }
+
+                public x2E Dot { get; }
+                public IEnumerable<Digit> Digits { get; }
+            }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Range : DecVal
+        {
+            public Range(x64 d, IEnumerable<Digit> digits, IEnumerable<Inner> inners)
+            {
+                D = d;
+                Digits = digits; //// TODO assert one or more
+                Inners = inners; //// TODO assert one or more
+            }
+
+            public x64 D { get; }
+            public IEnumerable<Digit> Digits { get; }
+            public IEnumerable<Inner> Inners { get; }
+
+            public sealed class Inner
+            {
+                public Inner(x2D dash, IEnumerable<Digit> digits)
+                {
+                    Dash = dash;
+                    Digits = digits; //// TODO assert one or more
+                }
+
+                public x2D Dash { get; }
+                public IEnumerable<Digit> Digits { get; }
+            }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/DefinedAs.cs b/odata/AbnfParser/CstNodes/DefinedAs.cs
new file mode 100644
index 0000000000..f66a72d6bc
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/DefinedAs.cs
@@ -0,0 +1,66 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public abstract class DefinedAs
+    {
+        private DefinedAs()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(DefinedAs node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(Declaration node, TContext context);
+            protected internal abstract TResult Accept(Incremental node, TContext context);
+        }
+
+        public sealed class Declaration : DefinedAs
+        {
+            public Declaration(IEnumerable<Cwsp> prefixCwsps, x3D equals, IEnumerable<Cwsp> suffixCwsps)
+            {
+                PrefixCwsps = prefixCwsps;
+                Equals = equals;
+                SuffixCwsps = suffixCwsps;
+            }
+
+            public IEnumerable<Cwsp> PrefixCwsps { get; }
+            public x3D Equals { get; }
+            public IEnumerable<Cwsp> SuffixCwsps { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Incremental : DefinedAs
+        {
+            public Incremental(IEnumerable<Cwsp> prefixCwsps, x3D equals, x2F slash, IEnumerable<Cwsp> suffixCwsps)
+            {
+                PrefixCwsps = prefixCwsps;
+                Equals = equals;
+                Slash = slash;
+                SuffixCwsps = suffixCwsps;
+            }
+
+            public IEnumerable<Cwsp> PrefixCwsps { get; }
+            public x3D Equals { get; }
+            public x2F Slash { get; }
+            public IEnumerable<Cwsp> SuffixCwsps { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Element.cs b/odata/AbnfParser/CstNodes/Element.cs
new file mode 100644
index 0000000000..82fd484f3a
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Element.cs
@@ -0,0 +1,116 @@
+namespace AbnfParser.CstNodes
+{
+    public abstract class Element
+    {
+        private Element()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Element node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(RuleName node, TContext context);
+            protected internal abstract TResult Accept(Group node, TContext context);
+            protected internal abstract TResult Accept(Option node, TContext context);
+            protected internal abstract TResult Accept(CharVal node, TContext context);
+            protected internal abstract TResult Accept(NumVal node, TContext context);
+            protected internal abstract TResult Accept(ProseVal node, TContext context);
+        }
+
+        public sealed class RuleName : Element
+        {
+            public RuleName(CstNodes.RuleName value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.RuleName Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Group : Element
+        {
+            public Group(CstNodes.Group value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.Group Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Option : Element
+        {
+            public Option(CstNodes.Option value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.Option Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class CharVal : Element
+        {
+            public CharVal(CstNodes.CharVal value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.CharVal Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class NumVal : Element
+        {
+            public NumVal(CstNodes.NumVal value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.NumVal Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ProseVal : Element
+        {
+            public ProseVal(CstNodes.ProseVal value)
+            {
+                Value = value;
+            }
+
+            public CstNodes.ProseVal Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Elements.cs b/odata/AbnfParser/CstNodes/Elements.cs
new file mode 100644
index 0000000000..588a836a78
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Elements.cs
@@ -0,0 +1,16 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    public sealed class Elements
+    {
+        public Elements(Alternation alternation, IEnumerable<Cwsp> cwsps)
+        {
+            Alternation = alternation;
+            Cwsps = cwsps;
+        }
+
+        public Alternation Alternation { get; }
+        public IEnumerable<Cwsp> Cwsps { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Group.cs b/odata/AbnfParser/CstNodes/Group.cs
new file mode 100644
index 0000000000..acb17d6487
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Group.cs
@@ -0,0 +1,29 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public sealed class Group
+    {
+        public Group(
+            x28 openParenthesis, 
+            IEnumerable<Cwsp> prefixCwsps, 
+            Alternation alternation, 
+            IEnumerable<Cwsp> suffixCwsps, 
+            x29 closeParenthesis)
+        {
+            OpenParenthesis = openParenthesis;
+            PrefixCwsps = prefixCwsps;
+            Alternation = alternation;
+            SuffixCwsps = suffixCwsps;
+            CloseParenthesis = closeParenthesis;
+        }
+
+        public x28 OpenParenthesis { get; }
+        public IEnumerable<Cwsp> PrefixCwsps { get; }
+        public Alternation Alternation { get; }
+        public IEnumerable<Cwsp> SuffixCwsps { get; }
+        public x29 CloseParenthesis { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/HexVal.cs b/odata/AbnfParser/CstNodes/HexVal.cs
new file mode 100644
index 0000000000..dd4c759c66
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/HexVal.cs
@@ -0,0 +1,105 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+    using System.Collections.Generic;
+
+    public abstract class HexVal
+    {
+        private HexVal()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(HexVal node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(HexOnly node, TContext context);
+            protected internal abstract TResult Accept(ConcatenatedHex node, TContext context);
+            protected internal abstract TResult Accept(Range node, TContext context);
+        }
+
+        public sealed class HexOnly : HexVal
+        {
+            public HexOnly(x78 x, IEnumerable<HexDig> hexDigs)
+            {
+                X = x;
+                HexDigs = hexDigs; //// TODO assert one or more
+            }
+
+            public x78 X { get; }
+            public IEnumerable<HexDig> HexDigs { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ConcatenatedHex : HexVal
+        {
+            public ConcatenatedHex(x78 x, IEnumerable<HexDig> hexDigs, IEnumerable<Inner> inners)
+            {
+                X = x;
+                HexDigs = hexDigs; //// TODO assert one or more
+                Inners = inners; //// TODO assert one or more
+            }
+
+            public x78 X { get; }
+            public IEnumerable<HexDig> HexDigs { get; }
+            public IEnumerable<Inner> Inners { get; }
+
+            public sealed class Inner
+            {
+                public Inner(x2E dot, IEnumerable<HexDig> hexDigs)
+                {
+                    Dot = dot;
+                    HexDigs = hexDigs; //// TODO assert one or more
+                }
+
+                public x2E Dot { get; }
+                public IEnumerable<HexDig> HexDigs { get; }
+            }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Range : HexVal
+        {
+            public Range(x78 x, IEnumerable<HexDig> hexDigs, IEnumerable<Inner> inners)
+            {
+                X = x;
+                HexDigs = hexDigs; //// TODO assert one or more
+                Inners = inners; //// TODO assert one or more
+            }
+
+            public x78 X { get; }
+            public IEnumerable<HexDig> HexDigs { get; }
+            public IEnumerable<Inner> Inners { get; }
+
+            public sealed class Inner
+            {
+                public Inner(x2D dash, IEnumerable<HexDig> hexDigs)
+                {
+                    Dash = dash;
+                    HexDigs = hexDigs; //// TODO assert one or more
+                }
+
+                public x2D Dash { get; }
+                public IEnumerable<HexDig> HexDigs { get; }
+            }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/NumVal.cs b/odata/AbnfParser/CstNodes/NumVal.cs
new file mode 100644
index 0000000000..195f67b605
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/NumVal.cs
@@ -0,0 +1,76 @@
+using AbnfParser.CstNodes.Core;
+
+namespace AbnfParser.CstNodes
+{
+    public abstract class NumVal
+    {
+        private NumVal()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(NumVal node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(BinVal node, TContext context);
+            protected internal abstract TResult Accept(DecVal node, TContext context);
+            protected internal abstract TResult Accept(HexVal node, TContext context);
+        }
+
+        public sealed class BinVal : NumVal
+        {
+            public BinVal(x25 percent, CstNodes.BinVal value)
+            {
+                Percent = percent;
+                Value = value;
+            }
+
+            public x25 Percent { get; }
+            public CstNodes.BinVal Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class DecVal : NumVal
+        {
+            public DecVal(x25 percent, CstNodes.DecVal value)
+            {
+                Percent = percent;
+                Value = value;
+            }
+
+            public x25 Percent { get; }
+            public CstNodes.DecVal Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class HexVal : NumVal
+        {
+            public HexVal(x25 percent, CstNodes.HexVal value)
+            {
+                Percent = percent;
+                Value = value;
+            }
+
+            public x25 Percent { get; }
+            public CstNodes.HexVal Value { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Option.cs b/odata/AbnfParser/CstNodes/Option.cs
new file mode 100644
index 0000000000..94df0f0107
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Option.cs
@@ -0,0 +1,28 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+    using System.Collections.Generic;
+
+    public sealed class Option
+    {
+        public Option(
+            x5B openBracket, 
+            IEnumerable<Cwsp> prefixCwsps, 
+            Alternation alternation, 
+            IEnumerable<Cwsp> suffixCwsps, 
+            x5D closeBracket)
+        {
+            OpenBracket = openBracket;
+            PrefixCwsps = prefixCwsps;
+            Alternation = alternation;
+            SuffixCwsps = suffixCwsps;
+            CloseBracket = closeBracket;
+        }
+
+        public x5B OpenBracket { get; }
+        public IEnumerable<Cwsp> PrefixCwsps { get; }
+        public Alternation Alternation { get; }
+        public IEnumerable<Cwsp> SuffixCwsps { get; }
+        public x5D CloseBracket { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/ProseVal.cs b/odata/AbnfParser/CstNodes/ProseVal.cs
new file mode 100644
index 0000000000..c02c45998c
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/ProseVal.cs
@@ -0,0 +1,1902 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+
+    public abstract class ProseVal
+    {
+        private ProseVal()
+        {
+        }
+
+        public abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(ProseVal node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(x20 node, TContext context);
+            protected internal abstract TResult Accept(x21 node, TContext context);
+            protected internal abstract TResult Accept(x22 node, TContext context);
+            protected internal abstract TResult Accept(x23 node, TContext context);
+            protected internal abstract TResult Accept(x24 node, TContext context);
+            protected internal abstract TResult Accept(x25 node, TContext context);
+            protected internal abstract TResult Accept(x26 node, TContext context);
+            protected internal abstract TResult Accept(x27 node, TContext context);
+            protected internal abstract TResult Accept(x28 node, TContext context);
+            protected internal abstract TResult Accept(x29 node, TContext context);
+            protected internal abstract TResult Accept(x2A node, TContext context);
+            protected internal abstract TResult Accept(x2B node, TContext context);
+            protected internal abstract TResult Accept(x2C node, TContext context);
+            protected internal abstract TResult Accept(x2D node, TContext context);
+            protected internal abstract TResult Accept(x2E node, TContext context);
+            protected internal abstract TResult Accept(x2F node, TContext context);
+            protected internal abstract TResult Accept(x30 node, TContext context);
+            protected internal abstract TResult Accept(x31 node, TContext context);
+            protected internal abstract TResult Accept(x32 node, TContext context);
+            protected internal abstract TResult Accept(x33 node, TContext context);
+            protected internal abstract TResult Accept(x34 node, TContext context);
+            protected internal abstract TResult Accept(x35 node, TContext context);
+            protected internal abstract TResult Accept(x36 node, TContext context);
+            protected internal abstract TResult Accept(x37 node, TContext context);
+            protected internal abstract TResult Accept(x38 node, TContext context);
+            protected internal abstract TResult Accept(x39 node, TContext context);
+            protected internal abstract TResult Accept(x3A node, TContext context);
+            protected internal abstract TResult Accept(x3B node, TContext context);
+            protected internal abstract TResult Accept(x3C node, TContext context);
+            protected internal abstract TResult Accept(x3D node, TContext context);
+            protected internal abstract TResult Accept(x3F node, TContext context);
+            protected internal abstract TResult Accept(x40 node, TContext context);
+            protected internal abstract TResult Accept(x41 node, TContext context);
+            protected internal abstract TResult Accept(x42 node, TContext context);
+            protected internal abstract TResult Accept(x43 node, TContext context);
+            protected internal abstract TResult Accept(x44 node, TContext context);
+            protected internal abstract TResult Accept(x45 node, TContext context);
+            protected internal abstract TResult Accept(x46 node, TContext context);
+            protected internal abstract TResult Accept(x47 node, TContext context);
+            protected internal abstract TResult Accept(x48 node, TContext context);
+            protected internal abstract TResult Accept(x49 node, TContext context);
+            protected internal abstract TResult Accept(x4A node, TContext context);
+            protected internal abstract TResult Accept(x4B node, TContext context);
+            protected internal abstract TResult Accept(x4C node, TContext context);
+            protected internal abstract TResult Accept(x4D node, TContext context);
+            protected internal abstract TResult Accept(x4E node, TContext context);
+            protected internal abstract TResult Accept(x4F node, TContext context);
+            protected internal abstract TResult Accept(x50 node, TContext context);
+            protected internal abstract TResult Accept(x51 node, TContext context);
+            protected internal abstract TResult Accept(x52 node, TContext context);
+            protected internal abstract TResult Accept(x53 node, TContext context);
+            protected internal abstract TResult Accept(x54 node, TContext context);
+            protected internal abstract TResult Accept(x55 node, TContext context);
+            protected internal abstract TResult Accept(x56 node, TContext context);
+            protected internal abstract TResult Accept(x57 node, TContext context);
+            protected internal abstract TResult Accept(x58 node, TContext context);
+            protected internal abstract TResult Accept(x59 node, TContext context);
+            protected internal abstract TResult Accept(x5A node, TContext context);
+            protected internal abstract TResult Accept(x5B node, TContext context);
+            protected internal abstract TResult Accept(x5C node, TContext context);
+            protected internal abstract TResult Accept(x5D node, TContext context);
+            protected internal abstract TResult Accept(x5E node, TContext context);
+            protected internal abstract TResult Accept(x5F node, TContext context);
+            protected internal abstract TResult Accept(x60 node, TContext context);
+            protected internal abstract TResult Accept(x61 node, TContext context);
+            protected internal abstract TResult Accept(x62 node, TContext context);
+            protected internal abstract TResult Accept(x63 node, TContext context);
+            protected internal abstract TResult Accept(x64 node, TContext context);
+            protected internal abstract TResult Accept(x65 node, TContext context);
+            protected internal abstract TResult Accept(x66 node, TContext context);
+            protected internal abstract TResult Accept(x67 node, TContext context);
+            protected internal abstract TResult Accept(x68 node, TContext context);
+            protected internal abstract TResult Accept(x69 node, TContext context);
+            protected internal abstract TResult Accept(x6A node, TContext context);
+            protected internal abstract TResult Accept(x6B node, TContext context);
+            protected internal abstract TResult Accept(x6C node, TContext context);
+            protected internal abstract TResult Accept(x6D node, TContext context);
+            protected internal abstract TResult Accept(x6E node, TContext context);
+            protected internal abstract TResult Accept(x6F node, TContext context);
+            protected internal abstract TResult Accept(x70 node, TContext context);
+            protected internal abstract TResult Accept(x71 node, TContext context);
+            protected internal abstract TResult Accept(x72 node, TContext context);
+            protected internal abstract TResult Accept(x73 node, TContext context);
+            protected internal abstract TResult Accept(x74 node, TContext context);
+            protected internal abstract TResult Accept(x75 node, TContext context);
+            protected internal abstract TResult Accept(x76 node, TContext context);
+            protected internal abstract TResult Accept(x77 node, TContext context);
+            protected internal abstract TResult Accept(x78 node, TContext context);
+            protected internal abstract TResult Accept(x79 node, TContext context);
+            protected internal abstract TResult Accept(x7A node, TContext context);
+            protected internal abstract TResult Accept(x7B node, TContext context);
+            protected internal abstract TResult Accept(x7C node, TContext context);
+            protected internal abstract TResult Accept(x7D node, TContext context);
+            protected internal abstract TResult Accept(x7E node, TContext context);
+        }
+
+        public sealed class x20 : ProseVal
+        {
+            public x20(Core.x3C lessThan, Core.x20 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x20 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x21 : ProseVal
+        {
+            public x21(Core.x3C lessThan, Core.x21 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x21 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x22 : ProseVal
+        {
+            public x22(Core.x3C lessThan, Core.x22 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x22 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x23 : ProseVal
+        {
+            public x23(Core.x3C lessThan, Core.x23 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x23 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x24 : ProseVal
+        {
+            public x24(Core.x3C lessThan, Core.x24 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x24 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x25 : ProseVal
+        {
+            public x25(Core.x3C lessThan, Core.x25 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x25 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x26 : ProseVal
+        {
+            public x26(Core.x3C lessThan, Core.x26 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x26 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x27 : ProseVal
+        {
+            public x27(Core.x3C lessThan, Core.x27 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x27 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x28 : ProseVal
+        {
+            public x28(Core.x3C lessThan, Core.x28 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x28 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x29 : ProseVal
+        {
+            public x29(Core.x3C lessThan, Core.x29 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x29 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2A : ProseVal
+        {
+            public x2A(Core.x3C lessThan, Core.x2A value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x2A Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2B : ProseVal
+        {
+            public x2B(Core.x3C lessThan, Core.x2B value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x2B Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2C : ProseVal
+        {
+            public x2C(Core.x3C lessThan, Core.x2C value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x2C Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2D : ProseVal
+        {
+            public x2D(Core.x3C lessThan, Core.x2D value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x2D Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2E : ProseVal
+        {
+            public x2E(Core.x3C lessThan, Core.x2E value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x2E Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x2F : ProseVal
+        {
+            public x2F(Core.x3C lessThan, Core.x2F value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x2F Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x30 : ProseVal
+        {
+            public x30(Core.x3C lessThan, Core.x30 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x30 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x31 : ProseVal
+        {
+            public x31(Core.x3C lessThan, Core.x31 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x31 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x32 : ProseVal
+        {
+            public x32(Core.x3C lessThan, Core.x32 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x32 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x33 : ProseVal
+        {
+            public x33(Core.x3C lessThan, Core.x33 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x33 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x34 : ProseVal
+        {
+            public x34(Core.x3C lessThan, Core.x34 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x34 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x35 : ProseVal
+        {
+            public x35(Core.x3C lessThan, Core.x35 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x35 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x36 : ProseVal
+        {
+            public x36(Core.x3C lessThan, Core.x36 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x36 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x37 : ProseVal
+        {
+            public x37(Core.x3C lessThan, Core.x37 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x37 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x38 : ProseVal
+        {
+            public x38(Core.x3C lessThan, Core.x38 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x38 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x39 : ProseVal
+        {
+            public x39(Core.x3C lessThan, Core.x39 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x39 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3A : ProseVal
+        {
+            public x3A(Core.x3C lessThan, Core.x3A value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x3A Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3B : ProseVal
+        {
+            public x3B(Core.x3C lessThan, Core.x3B value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x3B Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3C : ProseVal
+        {
+            public x3C(Core.x3C lessThan, Core.x3C value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x3C Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3D : ProseVal
+        {
+            public x3D(Core.x3C lessThan, Core.x3D value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x3D Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x3F : ProseVal
+        {
+            public x3F(Core.x3C lessThan, Core.x3F value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x3F Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x40 : ProseVal
+        {
+            public x40(Core.x3C lessThan, Core.x40 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x40 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x41 : ProseVal
+        {
+            public x41(Core.x3C lessThan, Core.x41 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x41 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x42 : ProseVal
+        {
+            public x42(Core.x3C lessThan, Core.x42 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x42 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x43 : ProseVal
+        {
+            public x43(Core.x3C lessThan, Core.x43 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x43 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x44 : ProseVal
+        {
+            public x44(Core.x3C lessThan, Core.x44 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x44 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x45 : ProseVal
+        {
+            public x45(Core.x3C lessThan, Core.x45 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x45 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x46 : ProseVal
+        {
+            public x46(Core.x3C lessThan, Core.x46 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x46 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x47 : ProseVal
+        {
+            public x47(Core.x3C lessThan, Core.x47 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x47 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x48 : ProseVal
+        {
+            public x48(Core.x3C lessThan, Core.x48 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x48 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x49 : ProseVal
+        {
+            public x49(Core.x3C lessThan, Core.x49 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x49 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4A : ProseVal
+        {
+            public x4A(Core.x3C lessThan, Core.x4A value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x4A Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4B : ProseVal
+        {
+            public x4B(Core.x3C lessThan, Core.x4B value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x4B Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4C : ProseVal
+        {
+            public x4C(Core.x3C lessThan, Core.x4C value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x4C Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4D : ProseVal
+        {
+            public x4D(Core.x3C lessThan, Core.x4D value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x4D Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4E : ProseVal
+        {
+            public x4E(Core.x3C lessThan, Core.x4E value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x4E Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x4F : ProseVal
+        {
+            public x4F(Core.x3C lessThan, Core.x4F value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x4F Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x50 : ProseVal
+        {
+            public x50(Core.x3C lessThan, Core.x50 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x50 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x51 : ProseVal
+        {
+            public x51(Core.x3C lessThan, Core.x51 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x51 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x52 : ProseVal
+        {
+            public x52(Core.x3C lessThan, Core.x52 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x52 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x53 : ProseVal
+        {
+            public x53(Core.x3C lessThan, Core.x53 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x53 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x54 : ProseVal
+        {
+            public x54(Core.x3C lessThan, Core.x54 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x54 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x55 : ProseVal
+        {
+            public x55(Core.x3C lessThan, Core.x55 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x55 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x56 : ProseVal
+        {
+            public x56(Core.x3C lessThan, Core.x56 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x56 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x57 : ProseVal
+        {
+            public x57(Core.x3C lessThan, Core.x57 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x57 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x58 : ProseVal
+        {
+            public x58(Core.x3C lessThan, Core.x58 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x58 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x59 : ProseVal
+        {
+            public x59(Core.x3C lessThan, Core.x59 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x59 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5A : ProseVal
+        {
+            public x5A(Core.x3C lessThan, Core.x5A value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x5A Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5B : ProseVal
+        {
+            public x5B(Core.x3C lessThan, Core.x5B value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x5B Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5C : ProseVal
+        {
+            public x5C(Core.x3C lessThan, Core.x5C value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x5C Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5D : ProseVal
+        {
+            public x5D(Core.x3C lessThan, Core.x5D value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x5D Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5E : ProseVal
+        {
+            public x5E(Core.x3C lessThan, Core.x5E value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x5E Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x5F : ProseVal
+        {
+            public x5F(Core.x3C lessThan, Core.x5F value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x5F Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x60 : ProseVal
+        {
+            public x60(Core.x3C lessThan, Core.x60 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x60 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x61 : ProseVal
+        {
+            public x61(Core.x3C lessThan, Core.x61 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x61 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x62 : ProseVal
+        {
+            public x62(Core.x3C lessThan, Core.x62 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x62 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x63 : ProseVal
+        {
+            public x63(Core.x3C lessThan, Core.x63 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x63 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x64 : ProseVal
+        {
+            public x64(Core.x3C lessThan, Core.x64 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x64 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x65 : ProseVal
+        {
+            public x65(Core.x3C lessThan, Core.x65 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x65 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x66 : ProseVal
+        {
+            public x66(Core.x3C lessThan, Core.x66 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x66 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x67 : ProseVal
+        {
+            public x67(Core.x3C lessThan, Core.x67 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x67 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x68 : ProseVal
+        {
+            public x68(Core.x3C lessThan, Core.x68 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x68 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x69 : ProseVal
+        {
+            public x69(Core.x3C lessThan, Core.x69 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x69 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6A : ProseVal
+        {
+            public x6A(Core.x3C lessThan, Core.x6A value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x6A Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6B : ProseVal
+        {
+            public x6B(Core.x3C lessThan, Core.x6B value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x6B Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6C : ProseVal
+        {
+            public x6C(Core.x3C lessThan, Core.x6C value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x6C Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6D : ProseVal
+        {
+            public x6D(Core.x3C lessThan, Core.x6D value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x6D Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6E : ProseVal
+        {
+            public x6E(Core.x3C lessThan, Core.x6E value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x6E Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x6F : ProseVal
+        {
+            public x6F(Core.x3C lessThan, Core.x6F value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x6F Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x70 : ProseVal
+        {
+            public x70(Core.x3C lessThan, Core.x70 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x70 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x71 : ProseVal
+        {
+            public x71(Core.x3C lessThan, Core.x71 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x71 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x72 : ProseVal
+        {
+            public x72(Core.x3C lessThan, Core.x72 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x72 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x73 : ProseVal
+        {
+            public x73(Core.x3C lessThan, Core.x73 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x73 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x74 : ProseVal
+        {
+            public x74(Core.x3C lessThan, Core.x74 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x74 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x75 : ProseVal
+        {
+            public x75(Core.x3C lessThan, Core.x75 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x75 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x76 : ProseVal
+        {
+            public x76(Core.x3C lessThan, Core.x76 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x76 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x77 : ProseVal
+        {
+            public x77(Core.x3C lessThan, Core.x77 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x77 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x78 : ProseVal
+        {
+            public x78(Core.x3C lessThan, Core.x78 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x78 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x79 : ProseVal
+        {
+            public x79(Core.x3C lessThan, Core.x79 value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x79 Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7A : ProseVal
+        {
+            public x7A(Core.x3C lessThan, Core.x7A value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x7A Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7B : ProseVal
+        {
+            public x7B(Core.x3C lessThan, Core.x7B value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x7B Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7C : ProseVal
+        {
+            public x7C(Core.x3C lessThan, Core.x7C value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x7C Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7D : ProseVal
+        {
+            public x7D(Core.x3C lessThan, Core.x7D value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x7D Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class x7E : ProseVal
+        {
+            public x7E(Core.x3C lessThan, Core.x7E value, Core.x3E greaterThan)
+            {
+                LessThan = lessThan;
+                Value = value;
+                GreaterThan = greaterThan;
+            }
+
+            public Core.x3C LessThan { get; }
+            public Core.x7E Value { get; }
+            public Core.x3E GreaterThan { get; }
+
+            public sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Repeat.cs b/odata/AbnfParser/CstNodes/Repeat.cs
new file mode 100644
index 0000000000..5aedf00ab9
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Repeat.cs
@@ -0,0 +1,61 @@
+namespace AbnfParser.CstNodes
+{
+    using System.Collections.Generic;
+
+    using AbnfParser.CstNodes.Core;
+
+    public abstract class Repeat
+    {
+        private Repeat()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Repeat node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(Count node, TContext context);
+            protected internal abstract TResult Accept(Range node, TContext context);
+        }
+
+        public sealed class Count : Repeat
+        {
+            public Count(IEnumerable<Digit> digits)
+            {
+                //// TODO assert one or more
+                Digits = digits;
+            }
+
+            public IEnumerable<Digit> Digits { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class Range : Repeat
+        {
+            public Range(IEnumerable<Digit> prefixDigits, x2A asterisk, IEnumerable<Digit> suffixDigits)
+            {
+                PrefixDigits = prefixDigits;
+                Asterisk = asterisk;
+                SuffixDigits = suffixDigits;
+            }
+
+            public IEnumerable<Digit> PrefixDigits { get; }
+            public x2A Asterisk { get; }
+            public IEnumerable<Digit> SuffixDigits { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Repetition.cs b/odata/AbnfParser/CstNodes/Repetition.cs
new file mode 100644
index 0000000000..3206e8e649
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Repetition.cs
@@ -0,0 +1,56 @@
+using AbnfParser.CstNodes.Core;
+
+namespace AbnfParser.CstNodes
+{
+    public abstract class Repetition
+    {
+        private Repetition()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Repetition node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            protected internal abstract TResult Accept(ElementOnly node, TContext context);
+            protected internal abstract TResult Accept(RepeatAndElement node, TContext context);
+        }
+
+        public sealed class ElementOnly : Repetition
+        {
+            public ElementOnly(Element element)
+            {
+                Element = element;
+            }
+
+            public Element Element { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class RepeatAndElement : Repetition
+        {
+            public RepeatAndElement(Repeat repeat, Element element)
+            {
+                Repeat = repeat;
+                Element = element;
+            }
+
+            public Repeat Repeat { get; }
+            public Element Element { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/Rule.cs b/odata/AbnfParser/CstNodes/Rule.cs
new file mode 100644
index 0000000000..158327a6f5
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/Rule.cs
@@ -0,0 +1,18 @@
+namespace AbnfParser.CstNodes
+{
+    public sealed class Rule
+    {
+        public Rule(RuleName ruleName, DefinedAs definedAs, Elements elements, Cnl cnl)
+        {
+            RuleName = ruleName;
+            DefinedAs = definedAs;
+            Elements = elements;
+            Cnl = cnl;
+        }
+
+        public RuleName RuleName { get; }
+        public DefinedAs DefinedAs { get; }
+        public Elements Elements { get; }
+        public Cnl Cnl { get; }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/RuleList.cs b/odata/AbnfParser/CstNodes/RuleList.cs
new file mode 100644
index 0000000000..3178fecf27
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/RuleList.cs
@@ -0,0 +1,71 @@
+namespace AbnfParser.CstNodes
+{
+    using AbnfParser.CstNodes.Core;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// https://www.rfc-editor.org/rfc/rfc5234
+    /// </summary>
+    public sealed class RuleList
+    {
+        public RuleList(IEnumerable<Inner> inners)
+        {
+            //// TODO assert one or more elements
+            Inners = inners;
+        }
+
+        public IEnumerable<Inner> Inners { get; }
+
+        public abstract class Inner
+        {
+            private Inner()
+            {
+            }
+
+            protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+            public abstract class Visitor<TResult, TContext>
+            {
+                public TResult Visit(Inner node, TContext context)
+                {
+                    return node.Dispatch(this, context);
+                }
+
+                protected internal abstract TResult Accept(RuleInner node, TContext context);
+                protected internal abstract TResult Accept(CommentInner node, TContext context);
+            }
+
+            public sealed class RuleInner : Inner
+            {
+                public RuleInner(Rule rule)
+                {
+                    Rule = rule;
+                }
+
+                public Rule Rule { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class CommentInner : Inner
+            {
+                public CommentInner(IEnumerable<Cwsp> cwsps, Cnl cnl)
+                {
+                    Cwsps = cwsps;
+                    Cnl = cnl;
+                }
+
+                public IEnumerable<Cwsp> Cwsps { get; }
+                public Cnl Cnl { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/CstNodes/RuleName.cs b/odata/AbnfParser/CstNodes/RuleName.cs
new file mode 100644
index 0000000000..23646093b5
--- /dev/null
+++ b/odata/AbnfParser/CstNodes/RuleName.cs
@@ -0,0 +1,83 @@
+using AbnfParser.CstNodes.Core;
+using System.Collections.Generic;
+
+namespace AbnfParser.CstNodes
+{
+    public sealed class RuleName
+    {
+        public RuleName(Alpha alpha, IEnumerable<Inner> inners)
+        {
+            Alpha = alpha;
+            Inners = inners;
+        }
+
+        public Alpha Alpha { get; }
+        public IEnumerable<Inner> Inners { get; }
+
+        public abstract class Inner
+        {
+            private Inner()
+            {
+            }
+
+            protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+            public abstract class Visitor<TResult, TContext>
+            {
+                public TResult Visit(Inner node, TContext context)
+                {
+                    return node.Dispatch(this, context);
+                }
+
+                protected internal abstract TResult Accept(AlphaInner node, TContext context);
+                protected internal abstract TResult Accept(DigitInner node, TContext context);
+                protected internal abstract TResult Accept(DashInner node, TContext context);
+            }
+
+            public sealed class AlphaInner : Inner
+            {
+                public AlphaInner(Alpha alpha)
+                {
+                    Alpha = alpha;
+                }
+
+                public Alpha Alpha { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class DigitInner : Inner
+            {
+                public DigitInner(Digit digit)
+                {
+                    Digit = digit;
+                }
+
+                public Digit Digit { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+
+            public sealed class DashInner : Inner
+            {
+                public DashInner(x2D dash)
+                {
+                    Dash = dash;
+                }
+
+                public x2D Dash { get; }
+
+                protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+                {
+                    return visitor.Accept(this, context);
+                }
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/AlternationTranscriber.cs b/odata/AbnfParser/Transcribers/AlternationTranscriber.cs
new file mode 100644
index 0000000000..8095f131a1
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/AlternationTranscriber.cs
@@ -0,0 +1,55 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class AlternationTranscriber
+    {
+        private AlternationTranscriber()
+        {
+        }
+
+        public static AlternationTranscriber Instance { get; } = new AlternationTranscriber();
+
+        public Void Transcribe(Alternation node, StringBuilder context)
+        {
+            ConcatenationTranscriber.Instance.Transcribe(node.Concatenation, context);
+            foreach (var inner in node.Inners)
+            {
+                InnerTranscriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class InnerTranscriber
+        {
+            private InnerTranscriber()
+            {
+            }
+
+            public static InnerTranscriber Instance { get; } = new InnerTranscriber();
+
+            public Void Transcribe(Alternation.Inner node, StringBuilder context)
+            {
+                foreach (var prefixCwsp in node.PrefixCwsps)
+                {
+                    CwspTranscriber.Instance.Visit(prefixCwsp, context);
+                }
+
+                x2FTranscriber.Instance.Transcribe(node.Slash, context);
+
+                foreach (var suffixCwsp in node.SuffixCwsps)
+                {
+                    CwspTranscriber.Instance.Visit(suffixCwsp, context);
+                }
+
+                ConcatenationTranscriber.Instance.Transcribe(node.Concatenation, context);
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/BinValTranscriber.cs b/odata/AbnfParser/Transcribers/BinValTranscriber.cs
new file mode 100644
index 0000000000..dbbb679c06
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/BinValTranscriber.cs
@@ -0,0 +1,100 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class BinValTranscriber : BinVal.Visitor<Void, StringBuilder>
+    {
+        private BinValTranscriber()
+        {
+        }
+
+        public static BinValTranscriber Instance { get; } = new BinValTranscriber();
+
+        protected internal override Void Accept(BinVal.BitsOnly node, StringBuilder context)
+        {
+            x62Transcriber.Instance.Transcribe(node.B, context);
+            foreach (var bit in node.Bits)
+            {
+                BitTranscriber.Instance.Visit(bit, context);
+            }
+
+            return default;
+        }
+
+        protected internal override Void Accept(BinVal.ConcatenatedBits node, StringBuilder context)
+        {
+            x62Transcriber.Instance.Transcribe(node.B, context);
+            foreach (var bit in node.Bits)
+            {
+                BitTranscriber.Instance.Visit(bit, context);
+            }
+
+            foreach (var inner in node.Inners)
+            {
+                ConcatenatedBitsInnerTranscriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class ConcatenatedBitsInnerTranscriber
+        {
+            private ConcatenatedBitsInnerTranscriber()
+            {
+            }
+
+            public static ConcatenatedBitsInnerTranscriber Instance { get; } = new ConcatenatedBitsInnerTranscriber();
+
+            public Void Transcribe(BinVal.ConcatenatedBits.Inner node, StringBuilder context)
+            {
+                x2ETranscriber.Instance.Transcribe(node.Dot, context);
+                foreach (var bit in node.Bits)
+                {
+                    BitTranscriber.Instance.Visit(bit, context);
+                }
+
+                return default;
+            }
+        }
+
+        protected internal override Void Accept(BinVal.Range node, StringBuilder context)
+        {
+            x62Transcriber.Instance.Transcribe(node.B, context);
+            foreach (var bit in node.Bits)
+            {
+                BitTranscriber.Instance.Visit(bit, context);
+            }
+
+            foreach (var inner in node.Inners)
+            {
+                RangeInnerTranscriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class RangeInnerTranscriber
+        {
+            private RangeInnerTranscriber()
+            {
+            }
+
+            public static RangeInnerTranscriber Instance { get; } = new RangeInnerTranscriber();
+
+            public Void Transcribe(BinVal.Range.Inner node, StringBuilder context)
+            {
+                x2DTranscriber.Instance.Transcribe(node.Dash, context);
+                foreach (var bit in node.Bits)
+                {
+                    BitTranscriber.Instance.Visit(bit, context);
+                }
+
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/CharValTranscriber.cs b/odata/AbnfParser/Transcribers/CharValTranscriber.cs
new file mode 100644
index 0000000000..ad58147f37
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/CharValTranscriber.cs
@@ -0,0 +1,510 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class CharValTranscriber
+    {
+        private CharValTranscriber()
+        {
+        }
+
+        public static CharValTranscriber Instance { get; } = new CharValTranscriber();
+
+        public Void Transcribe(CharVal node, StringBuilder context)
+        {
+            DquoteTranscriber.Instance.Transcribe(node.OpenDquote, context);
+            foreach (var inner in node.Inners)
+            {
+                InnerTranscriber.Instance.Visit(inner, context);
+            }
+
+            DquoteTranscriber.Instance.Transcribe(node.CloseDquote, context);
+            return default;
+        }
+
+        public sealed class InnerTranscriber : CharVal.Inner.Visitor<Void, StringBuilder>
+        {
+            private InnerTranscriber()
+            {
+            }
+
+            public static InnerTranscriber Instance { get; } = new InnerTranscriber();
+
+            protected internal override Void Accept(CharVal.Inner.x20 node, StringBuilder context)
+            {
+                return x20Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x21 node, StringBuilder context)
+            {
+                return x21Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x23 node, StringBuilder context)
+            {
+                return x23Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x24 node, StringBuilder context)
+            {
+                return x24Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x25 node, StringBuilder context)
+            {
+                return x25Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x26 node, StringBuilder context)
+            {
+                return x26Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x27 node, StringBuilder context)
+            {
+                return x27Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x28 node, StringBuilder context)
+            {
+                return x28Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x29 node, StringBuilder context)
+            {
+                return x29Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x2A node, StringBuilder context)
+            {
+                return x2ATranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x2B node, StringBuilder context)
+            {
+                return x2BTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x2C node, StringBuilder context)
+            {
+                return x2CTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x2D node, StringBuilder context)
+            {
+                return x2DTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x2E node, StringBuilder context)
+            {
+                return x2ETranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x2F node, StringBuilder context)
+            {
+                return x2FTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x30 node, StringBuilder context)
+            {
+                return x30Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x31 node, StringBuilder context)
+            {
+                return x31Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x32 node, StringBuilder context)
+            {
+                return x32Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x33 node, StringBuilder context)
+            {
+                return x33Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x34 node, StringBuilder context)
+            {
+                return x34Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x35 node, StringBuilder context)
+            {
+                return x35Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x36 node, StringBuilder context)
+            {
+                return x36Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x37 node, StringBuilder context)
+            {
+                return x37Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x38 node, StringBuilder context)
+            {
+                return x38Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x39 node, StringBuilder context)
+            {
+                return x39Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x3A node, StringBuilder context)
+            {
+                return x3ATranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x3B node, StringBuilder context)
+            {
+                return x3BTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x3C node, StringBuilder context)
+            {
+                return x3CTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x3D node, StringBuilder context)
+            {
+                return x3DTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x3E node, StringBuilder context)
+            {
+                return x3ETranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x3F node, StringBuilder context)
+            {
+                return x3FTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x40 node, StringBuilder context)
+            {
+                return x40Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x41 node, StringBuilder context)
+            {
+                return x41Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x42 node, StringBuilder context)
+            {
+                return x42Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x43 node, StringBuilder context)
+            {
+                return x43Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x44 node, StringBuilder context)
+            {
+                return x44Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x45 node, StringBuilder context)
+            {
+                return x45Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x46 node, StringBuilder context)
+            {
+                return x46Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x47 node, StringBuilder context)
+            {
+                return x47Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x48 node, StringBuilder context)
+            {
+                return x48Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x49 node, StringBuilder context)
+            {
+                return x49Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x4A node, StringBuilder context)
+            {
+                return x4ATranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x4B node, StringBuilder context)
+            {
+                return x4BTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x4C node, StringBuilder context)
+            {
+                return x4CTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x4D node, StringBuilder context)
+            {
+                return x4DTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x4E node, StringBuilder context)
+            {
+                return x4ETranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x4F node, StringBuilder context)
+            {
+                return x4FTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x50 node, StringBuilder context)
+            {
+                return x50Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x51 node, StringBuilder context)
+            {
+                return x51Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x52 node, StringBuilder context)
+            {
+                return x52Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x53 node, StringBuilder context)
+            {
+                return x53Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x54 node, StringBuilder context)
+            {
+                return x54Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x55 node, StringBuilder context)
+            {
+                return x55Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x56 node, StringBuilder context)
+            {
+                return x56Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x57 node, StringBuilder context)
+            {
+                return x57Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x58 node, StringBuilder context)
+            {
+                return x58Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x59 node, StringBuilder context)
+            {
+                return x59Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x5A node, StringBuilder context)
+            {
+                return x5ATranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x5B node, StringBuilder context)
+            {
+                return x5BTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x5C node, StringBuilder context)
+            {
+                return x5CTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x5D node, StringBuilder context)
+            {
+                return x5DTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x5E node, StringBuilder context)
+            {
+                return x5ETranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x5F node, StringBuilder context)
+            {
+                return x5FTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x60 node, StringBuilder context)
+            {
+                return x60Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x61 node, StringBuilder context)
+            {
+                return x61Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x62 node, StringBuilder context)
+            {
+                return x62Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x63 node, StringBuilder context)
+            {
+                return x63Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x64 node, StringBuilder context)
+            {
+                return x64Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x65 node, StringBuilder context)
+            {
+                return x65Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x66 node, StringBuilder context)
+            {
+                return x66Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x67 node, StringBuilder context)
+            {
+                return x67Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x68 node, StringBuilder context)
+            {
+                return x68Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x69 node, StringBuilder context)
+            {
+                return x69Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x6A node, StringBuilder context)
+            {
+                return x6ATranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x6B node, StringBuilder context)
+            {
+                return x6BTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x6C node, StringBuilder context)
+            {
+                return x6CTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x6D node, StringBuilder context)
+            {
+                return x6DTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x6E node, StringBuilder context)
+            {
+                return x6ETranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x6F node, StringBuilder context)
+            {
+                return x6FTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x70 node, StringBuilder context)
+            {
+                return x70Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x71 node, StringBuilder context)
+            {
+                return x71Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x72 node, StringBuilder context)
+            {
+                return x72Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x73 node, StringBuilder context)
+            {
+                return x73Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x74 node, StringBuilder context)
+            {
+                return x74Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x75 node, StringBuilder context)
+            {
+                return x75Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x76 node, StringBuilder context)
+            {
+                return x76Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x77 node, StringBuilder context)
+            {
+                return x77Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x78 node, StringBuilder context)
+            {
+                return x78Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x79 node, StringBuilder context)
+            {
+                return x79Transcriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x7A node, StringBuilder context)
+            {
+                return x7ATranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x7B node, StringBuilder context)
+            {
+                return x7BTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x7C node, StringBuilder context)
+            {
+                return x7CTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x7D node, StringBuilder context)
+            {
+                return x7DTranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+            protected internal override Void Accept(CharVal.Inner.x7E node, StringBuilder context)
+            {
+                return x7ETranscriber.Instance.Transcribe(node.Value, context);
+            }
+
+        }
+
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/CnlTranscriber.cs b/odata/AbnfParser/Transcribers/CnlTranscriber.cs
new file mode 100644
index 0000000000..4aadfd7c79
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/CnlTranscriber.cs
@@ -0,0 +1,29 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class CnlTranscriber : Cnl.Visitor<Void, StringBuilder>
+    {
+        private CnlTranscriber()
+        {
+        }
+
+        public static CnlTranscriber Instance { get; } = new CnlTranscriber();
+
+        protected internal override Void Accept(Cnl.Comment node, StringBuilder context)
+        {
+            CommentTranscriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Cnl.Newline node, StringBuilder context)
+        {
+            CrlfTranscriber.Instance.Transcribe(node.Crlf, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/CommentTranscriber.cs b/odata/AbnfParser/Transcribers/CommentTranscriber.cs
new file mode 100644
index 0000000000..07adb6ae4a
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/CommentTranscriber.cs
@@ -0,0 +1,50 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class CommentTranscriber
+    {
+        private CommentTranscriber()
+        {
+        }
+
+        public static CommentTranscriber Instance { get; } = new CommentTranscriber();
+
+        public Void Transcribe(Comment node, StringBuilder context)
+        {
+            x3BTranscriber.Instance.Transcribe(node.Semicolon, context);
+            foreach (var inner in node.Inners)
+            {
+                InnerTranscriber.Instance.Visit(inner, context);
+            }
+
+            CrlfTranscriber.Instance.Transcribe(node.Crlf, context);
+            return default;
+        }
+
+        public sealed class InnerTranscriber : Comment.Inner.Visitor<Void, StringBuilder>
+        {
+            private InnerTranscriber()
+            {
+            }
+
+            public static InnerTranscriber Instance { get; } = new InnerTranscriber();
+
+            protected internal override Void Accept(Comment.Inner.InnerWsp node, StringBuilder context)
+            {
+                WspTranscriber.Instance.Visit(node.Wsp, context);
+                return default;
+            }
+
+            protected internal override Void Accept(Comment.Inner.InnerVchar node, StringBuilder context)
+            {
+                VcharTranscriber.Instance.Visit(node.Vchar, context);
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/ConcatenationTranscriber.cs b/odata/AbnfParser/Transcribers/ConcatenationTranscriber.cs
new file mode 100644
index 0000000000..9a82fdda26
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/ConcatenationTranscriber.cs
@@ -0,0 +1,47 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using Root;
+
+    public sealed class ConcatenationTranscriber
+    {
+        private ConcatenationTranscriber()
+        {
+        }
+
+        public static ConcatenationTranscriber Instance { get; } = new ConcatenationTranscriber();
+
+        public Void Transcribe(Concatenation node, StringBuilder context)
+        {
+            RepetitionTranscriber.Instance.Visit(node.Repetition, context);
+            foreach (var inner in node.Inners)
+            {
+                InnerTranscriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class InnerTranscriber
+        {
+            private InnerTranscriber()
+            {
+            }
+
+            public static InnerTranscriber Instance { get; } = new InnerTranscriber();
+
+            public Void Transcribe(Concatenation.Inner node, StringBuilder context)
+            {
+                foreach (var cwsp in node.Cwsps)
+                {
+                    CwspTranscriber.Instance.Visit(cwsp, context);
+                }
+
+                RepetitionTranscriber.Instance.Visit(node.Repetition, context);
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/AlphaTranscriber.cs b/odata/AbnfParser/Transcribers/Core/AlphaTranscriber.cs
new file mode 100644
index 0000000000..d5d278c1de
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/AlphaTranscriber.cs
@@ -0,0 +1,278 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class AlphaTranscriber : Alpha.Visitor<Root.Void, StringBuilder>
+    {
+        private AlphaTranscriber()
+        {
+        }
+
+        public static AlphaTranscriber Instance { get; } = new AlphaTranscriber();
+
+        protected internal override Void Accept(Alpha.x41 node, StringBuilder context)
+        {
+            return x41Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x42 node, StringBuilder context)
+        {
+            return x42Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x43 node, StringBuilder context)
+        {
+            return x43Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x44 node, StringBuilder context)
+        {
+            return x44Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x45 node, StringBuilder context)
+        {
+            return x45Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x46 node, StringBuilder context)
+        {
+            return x46Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x47 node, StringBuilder context)
+        {
+            return x47Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x48 node, StringBuilder context)
+        {
+            return x48Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x49 node, StringBuilder context)
+        {
+            return x49Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x4A node, StringBuilder context)
+        {
+            return x4ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x4B node, StringBuilder context)
+        {
+            return x4BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x4C node, StringBuilder context)
+        {
+            return x4CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x4D node, StringBuilder context)
+        {
+            return x4DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x4E node, StringBuilder context)
+        {
+            return x4ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x4F node, StringBuilder context)
+        {
+            return x4FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x50 node, StringBuilder context)
+        {
+            return x50Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x51 node, StringBuilder context)
+        {
+            return x51Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x52 node, StringBuilder context)
+        {
+            return x52Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x53 node, StringBuilder context)
+        {
+            return x53Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x54 node, StringBuilder context)
+        {
+            return x54Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x55 node, StringBuilder context)
+        {
+            return x55Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x56 node, StringBuilder context)
+        {
+            return x56Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x57 node, StringBuilder context)
+        {
+            return x57Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x58 node, StringBuilder context)
+        {
+            return x58Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x59 node, StringBuilder context)
+        {
+            return x59Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x5A node, StringBuilder context)
+        {
+            return x5ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x61 node, StringBuilder context)
+        {
+            return x61Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x62 node, StringBuilder context)
+        {
+            return x62Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x63 node, StringBuilder context)
+        {
+            return x63Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x64 node, StringBuilder context)
+        {
+            return x64Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x65 node, StringBuilder context)
+        {
+            return x65Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x66 node, StringBuilder context)
+        {
+            return x66Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x67 node, StringBuilder context)
+        {
+            return x67Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x68 node, StringBuilder context)
+        {
+            return x68Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x69 node, StringBuilder context)
+        {
+            return x69Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x6A node, StringBuilder context)
+        {
+            return x6ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x6B node, StringBuilder context)
+        {
+            return x6BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x6C node, StringBuilder context)
+        {
+            return x6CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x6D node, StringBuilder context)
+        {
+            return x6DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x6E node, StringBuilder context)
+        {
+            return x6ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x6F node, StringBuilder context)
+        {
+            return x6FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x70 node, StringBuilder context)
+        {
+            return x70Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x71 node, StringBuilder context)
+        {
+            return x71Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x72 node, StringBuilder context)
+        {
+            return x72Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x73 node, StringBuilder context)
+        {
+            return x73Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x74 node, StringBuilder context)
+        {
+            return x74Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x75 node, StringBuilder context)
+        {
+            return x75Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x76 node, StringBuilder context)
+        {
+            return x76Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x77 node, StringBuilder context)
+        {
+            return x77Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x78 node, StringBuilder context)
+        {
+            return x78Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x79 node, StringBuilder context)
+        {
+            return x79Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Alpha.x7A node, StringBuilder context)
+        {
+            return x7ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+    }
+
+}
diff --git a/odata/AbnfParser/Transcribers/Core/BitTranscriber.cs b/odata/AbnfParser/Transcribers/Core/BitTranscriber.cs
new file mode 100644
index 0000000000..26acb7f2fd
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/BitTranscriber.cs
@@ -0,0 +1,26 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class BitTranscriber : Bit.Visitor<Void, StringBuilder>
+    {
+        private BitTranscriber()
+        {
+        }
+
+        public static BitTranscriber Instance { get; } = new BitTranscriber();
+
+        protected internal override Void Accept(Bit.Zero node, StringBuilder context)
+        {
+            return x30Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Bit.One node, StringBuilder context)
+        {
+            return x31Transcriber.Instance.Transcribe(node.Value, context);
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/CharTranscriber.cs b/odata/AbnfParser/Transcribers/Core/CharTranscriber.cs
new file mode 100644
index 0000000000..78f842cde6
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/CharTranscriber.cs
@@ -0,0 +1,652 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class CharTranscriber : Char.Visitor<Void, StringBuilder>
+    {
+        private CharTranscriber()
+        {
+        }
+
+        public static CharTranscriber Instance { get; } = new CharTranscriber();
+
+        protected internal override Void Accept(Char.x01 node, StringBuilder context)
+        {
+            return x01Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x02 node, StringBuilder context)
+        {
+            return x02Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x03 node, StringBuilder context)
+        {
+            return x03Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x04 node, StringBuilder context)
+        {
+            return x04Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x05 node, StringBuilder context)
+        {
+            return x05Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x06 node, StringBuilder context)
+        {
+            return x06Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x07 node, StringBuilder context)
+        {
+            return x07Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x08 node, StringBuilder context)
+        {
+            return x08Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x09 node, StringBuilder context)
+        {
+            return x09Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x0A node, StringBuilder context)
+        {
+            return x0ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x0B node, StringBuilder context)
+        {
+            return x0BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x0C node, StringBuilder context)
+        {
+            return x0CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x0D node, StringBuilder context)
+        {
+            return x0DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x0E node, StringBuilder context)
+        {
+            return x0ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x0F node, StringBuilder context)
+        {
+            return x0FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x10 node, StringBuilder context)
+        {
+            return x10Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x11 node, StringBuilder context)
+        {
+            return x11Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x12 node, StringBuilder context)
+        {
+            return x12Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x13 node, StringBuilder context)
+        {
+            return x13Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x14 node, StringBuilder context)
+        {
+            return x14Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x15 node, StringBuilder context)
+        {
+            return x15Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x16 node, StringBuilder context)
+        {
+            return x16Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x17 node, StringBuilder context)
+        {
+            return x17Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x18 node, StringBuilder context)
+        {
+            return x18Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x19 node, StringBuilder context)
+        {
+            return x19Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x1A node, StringBuilder context)
+        {
+            return x1ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x1B node, StringBuilder context)
+        {
+            return x1BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x1C node, StringBuilder context)
+        {
+            return x1CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x1D node, StringBuilder context)
+        {
+            return x1DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x1E node, StringBuilder context)
+        {
+            return x1ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x1F node, StringBuilder context)
+        {
+            return x1FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x20 node, StringBuilder context)
+        {
+            return x20Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x21 node, StringBuilder context)
+        {
+            return x21Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x22 node, StringBuilder context)
+        {
+            return x22Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x23 node, StringBuilder context)
+        {
+            return x23Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x24 node, StringBuilder context)
+        {
+            return x24Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x25 node, StringBuilder context)
+        {
+            return x25Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x26 node, StringBuilder context)
+        {
+            return x26Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x27 node, StringBuilder context)
+        {
+            return x27Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x28 node, StringBuilder context)
+        {
+            return x28Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x29 node, StringBuilder context)
+        {
+            return x29Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x2A node, StringBuilder context)
+        {
+            return x2ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x2B node, StringBuilder context)
+        {
+            return x2BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x2C node, StringBuilder context)
+        {
+            return x2CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x2D node, StringBuilder context)
+        {
+            return x2DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x2E node, StringBuilder context)
+        {
+            return x2ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x2F node, StringBuilder context)
+        {
+            return x2FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x30 node, StringBuilder context)
+        {
+            return x30Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x31 node, StringBuilder context)
+        {
+            return x31Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x32 node, StringBuilder context)
+        {
+            return x32Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x33 node, StringBuilder context)
+        {
+            return x33Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x34 node, StringBuilder context)
+        {
+            return x34Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x35 node, StringBuilder context)
+        {
+            return x35Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x36 node, StringBuilder context)
+        {
+            return x36Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x37 node, StringBuilder context)
+        {
+            return x37Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x38 node, StringBuilder context)
+        {
+            return x38Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x39 node, StringBuilder context)
+        {
+            return x39Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x3A node, StringBuilder context)
+        {
+            return x3ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x3B node, StringBuilder context)
+        {
+            return x3BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x3C node, StringBuilder context)
+        {
+            return x3CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x3D node, StringBuilder context)
+        {
+            return x3DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x3E node, StringBuilder context)
+        {
+            return x3ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x3F node, StringBuilder context)
+        {
+            return x3FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x40 node, StringBuilder context)
+        {
+            return x40Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x41 node, StringBuilder context)
+        {
+            return x41Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x42 node, StringBuilder context)
+        {
+            return x42Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x43 node, StringBuilder context)
+        {
+            return x43Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x44 node, StringBuilder context)
+        {
+            return x44Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x45 node, StringBuilder context)
+        {
+            return x45Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x46 node, StringBuilder context)
+        {
+            return x46Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x47 node, StringBuilder context)
+        {
+            return x47Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x48 node, StringBuilder context)
+        {
+            return x48Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x49 node, StringBuilder context)
+        {
+            return x49Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x4A node, StringBuilder context)
+        {
+            return x4ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x4B node, StringBuilder context)
+        {
+            return x4BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x4C node, StringBuilder context)
+        {
+            return x4CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x4D node, StringBuilder context)
+        {
+            return x4DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x4E node, StringBuilder context)
+        {
+            return x4ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x4F node, StringBuilder context)
+        {
+            return x4FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x50 node, StringBuilder context)
+        {
+            return x50Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x51 node, StringBuilder context)
+        {
+            return x51Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x52 node, StringBuilder context)
+        {
+            return x52Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x53 node, StringBuilder context)
+        {
+            return x53Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x54 node, StringBuilder context)
+        {
+            return x54Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x55 node, StringBuilder context)
+        {
+            return x55Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x56 node, StringBuilder context)
+        {
+            return x56Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x57 node, StringBuilder context)
+        {
+            return x57Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x58 node, StringBuilder context)
+        {
+            return x58Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x59 node, StringBuilder context)
+        {
+            return x59Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x5A node, StringBuilder context)
+        {
+            return x5ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x5B node, StringBuilder context)
+        {
+            return x5BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x5C node, StringBuilder context)
+        {
+            return x5CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x5D node, StringBuilder context)
+        {
+            return x5DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x5E node, StringBuilder context)
+        {
+            return x5ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x5F node, StringBuilder context)
+        {
+            return x5FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x60 node, StringBuilder context)
+        {
+            return x60Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x61 node, StringBuilder context)
+        {
+            return x61Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x62 node, StringBuilder context)
+        {
+            return x62Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x63 node, StringBuilder context)
+        {
+            return x63Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x64 node, StringBuilder context)
+        {
+            return x64Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x65 node, StringBuilder context)
+        {
+            return x65Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x66 node, StringBuilder context)
+        {
+            return x66Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x67 node, StringBuilder context)
+        {
+            return x67Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x68 node, StringBuilder context)
+        {
+            return x68Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x69 node, StringBuilder context)
+        {
+            return x69Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x6A node, StringBuilder context)
+        {
+            return x6ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x6B node, StringBuilder context)
+        {
+            return x6BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x6C node, StringBuilder context)
+        {
+            return x6CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x6D node, StringBuilder context)
+        {
+            return x6DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x6E node, StringBuilder context)
+        {
+            return x6ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x6F node, StringBuilder context)
+        {
+            return x6FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x70 node, StringBuilder context)
+        {
+            return x70Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x71 node, StringBuilder context)
+        {
+            return x71Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x72 node, StringBuilder context)
+        {
+            return x72Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x73 node, StringBuilder context)
+        {
+            return x73Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x74 node, StringBuilder context)
+        {
+            return x74Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x75 node, StringBuilder context)
+        {
+            return x75Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x76 node, StringBuilder context)
+        {
+            return x76Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x77 node, StringBuilder context)
+        {
+            return x77Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x78 node, StringBuilder context)
+        {
+            return x78Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x79 node, StringBuilder context)
+        {
+            return x79Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x7A node, StringBuilder context)
+        {
+            return x7ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x7B node, StringBuilder context)
+        {
+            return x7BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x7C node, StringBuilder context)
+        {
+            return x7CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x7D node, StringBuilder context)
+        {
+            return x7DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x7E node, StringBuilder context)
+        {
+            return x7ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Char.x7F node, StringBuilder context)
+        {
+            return x7FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/CharTranscribers.cs b/odata/AbnfParser/Transcribers/Core/CharTranscribers.cs
new file mode 100644
index 0000000000..354ab279c5
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/CharTranscribers.cs
@@ -0,0 +1,1786 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class x01Transcriber
+    {
+        private x01Transcriber()
+        {
+        }
+
+        public static x01Transcriber Instance { get; } = new x01Transcriber();
+
+        public Void Transcribe(x01 node, StringBuilder context)
+        {
+            context.Append((char)0x01);
+            return default;
+        }
+    }
+    public sealed class x02Transcriber
+    {
+        private x02Transcriber()
+        {
+        }
+
+        public static x02Transcriber Instance { get; } = new x02Transcriber();
+
+        public Void Transcribe(x02 node, StringBuilder context)
+        {
+            context.Append((char)0x02);
+            return default;
+        }
+    }
+    public sealed class x03Transcriber
+    {
+        private x03Transcriber()
+        {
+        }
+
+        public static x03Transcriber Instance { get; } = new x03Transcriber();
+
+        public Void Transcribe(x03 node, StringBuilder context)
+        {
+            context.Append((char)0x03);
+            return default;
+        }
+    }
+    public sealed class x04Transcriber
+    {
+        private x04Transcriber()
+        {
+        }
+
+        public static x04Transcriber Instance { get; } = new x04Transcriber();
+
+        public Void Transcribe(x04 node, StringBuilder context)
+        {
+            context.Append((char)0x04);
+            return default;
+        }
+    }
+    public sealed class x05Transcriber
+    {
+        private x05Transcriber()
+        {
+        }
+
+        public static x05Transcriber Instance { get; } = new x05Transcriber();
+
+        public Void Transcribe(x05 node, StringBuilder context)
+        {
+            context.Append((char)0x05);
+            return default;
+        }
+    }
+    public sealed class x06Transcriber
+    {
+        private x06Transcriber()
+        {
+        }
+
+        public static x06Transcriber Instance { get; } = new x06Transcriber();
+
+        public Void Transcribe(x06 node, StringBuilder context)
+        {
+            context.Append((char)0x06);
+            return default;
+        }
+    }
+    public sealed class x07Transcriber
+    {
+        private x07Transcriber()
+        {
+        }
+
+        public static x07Transcriber Instance { get; } = new x07Transcriber();
+
+        public Void Transcribe(x07 node, StringBuilder context)
+        {
+            context.Append((char)0x07);
+            return default;
+        }
+    }
+    public sealed class x08Transcriber
+    {
+        private x08Transcriber()
+        {
+        }
+
+        public static x08Transcriber Instance { get; } = new x08Transcriber();
+
+        public Void Transcribe(x08 node, StringBuilder context)
+        {
+            context.Append((char)0x08);
+            return default;
+        }
+    }
+    public sealed class x09Transcriber
+    {
+        private x09Transcriber()
+        {
+        }
+
+        public static x09Transcriber Instance { get; } = new x09Transcriber();
+
+        public Void Transcribe(x09 node, StringBuilder context)
+        {
+            context.Append((char)0x09);
+            return default;
+        }
+    }
+    public sealed class x0ATranscriber
+    {
+        private x0ATranscriber()
+        {
+        }
+
+        public static x0ATranscriber Instance { get; } = new x0ATranscriber();
+
+        public Void Transcribe(x0A node, StringBuilder context)
+        {
+            context.Append((char)0x0A);
+            return default;
+        }
+    }
+    public sealed class x0BTranscriber
+    {
+        private x0BTranscriber()
+        {
+        }
+
+        public static x0BTranscriber Instance { get; } = new x0BTranscriber();
+
+        public Void Transcribe(x0B node, StringBuilder context)
+        {
+            context.Append((char)0x0B);
+            return default;
+        }
+    }
+    public sealed class x0CTranscriber
+    {
+        private x0CTranscriber()
+        {
+        }
+
+        public static x0CTranscriber Instance { get; } = new x0CTranscriber();
+
+        public Void Transcribe(x0C node, StringBuilder context)
+        {
+            context.Append((char)0x0C);
+            return default;
+        }
+    }
+    public sealed class x0DTranscriber
+    {
+        private x0DTranscriber()
+        {
+        }
+
+        public static x0DTranscriber Instance { get; } = new x0DTranscriber();
+
+        public Void Transcribe(x0D node, StringBuilder context)
+        {
+            context.Append((char)0x0D);
+            return default;
+        }
+    }
+    public sealed class x0ETranscriber
+    {
+        private x0ETranscriber()
+        {
+        }
+
+        public static x0ETranscriber Instance { get; } = new x0ETranscriber();
+
+        public Void Transcribe(x0E node, StringBuilder context)
+        {
+            context.Append((char)0x0E);
+            return default;
+        }
+    }
+    public sealed class x0FTranscriber
+    {
+        private x0FTranscriber()
+        {
+        }
+
+        public static x0FTranscriber Instance { get; } = new x0FTranscriber();
+
+        public Void Transcribe(x0F node, StringBuilder context)
+        {
+            context.Append((char)0x0F);
+            return default;
+        }
+    }
+    public sealed class x10Transcriber
+    {
+        private x10Transcriber()
+        {
+        }
+
+        public static x10Transcriber Instance { get; } = new x10Transcriber();
+
+        public Void Transcribe(x10 node, StringBuilder context)
+        {
+            context.Append((char)0x10);
+            return default;
+        }
+    }
+    public sealed class x11Transcriber
+    {
+        private x11Transcriber()
+        {
+        }
+
+        public static x11Transcriber Instance { get; } = new x11Transcriber();
+
+        public Void Transcribe(x11 node, StringBuilder context)
+        {
+            context.Append((char)0x11);
+            return default;
+        }
+    }
+    public sealed class x12Transcriber
+    {
+        private x12Transcriber()
+        {
+        }
+
+        public static x12Transcriber Instance { get; } = new x12Transcriber();
+
+        public Void Transcribe(x12 node, StringBuilder context)
+        {
+            context.Append((char)0x12);
+            return default;
+        }
+    }
+    public sealed class x13Transcriber
+    {
+        private x13Transcriber()
+        {
+        }
+
+        public static x13Transcriber Instance { get; } = new x13Transcriber();
+
+        public Void Transcribe(x13 node, StringBuilder context)
+        {
+            context.Append((char)0x13);
+            return default;
+        }
+    }
+    public sealed class x14Transcriber
+    {
+        private x14Transcriber()
+        {
+        }
+
+        public static x14Transcriber Instance { get; } = new x14Transcriber();
+
+        public Void Transcribe(x14 node, StringBuilder context)
+        {
+            context.Append((char)0x14);
+            return default;
+        }
+    }
+    public sealed class x15Transcriber
+    {
+        private x15Transcriber()
+        {
+        }
+
+        public static x15Transcriber Instance { get; } = new x15Transcriber();
+
+        public Void Transcribe(x15 node, StringBuilder context)
+        {
+            context.Append((char)0x15);
+            return default;
+        }
+    }
+    public sealed class x16Transcriber
+    {
+        private x16Transcriber()
+        {
+        }
+
+        public static x16Transcriber Instance { get; } = new x16Transcriber();
+
+        public Void Transcribe(x16 node, StringBuilder context)
+        {
+            context.Append((char)0x16);
+            return default;
+        }
+    }
+    public sealed class x17Transcriber
+    {
+        private x17Transcriber()
+        {
+        }
+
+        public static x17Transcriber Instance { get; } = new x17Transcriber();
+
+        public Void Transcribe(x17 node, StringBuilder context)
+        {
+            context.Append((char)0x17);
+            return default;
+        }
+    }
+    public sealed class x18Transcriber
+    {
+        private x18Transcriber()
+        {
+        }
+
+        public static x18Transcriber Instance { get; } = new x18Transcriber();
+
+        public Void Transcribe(x18 node, StringBuilder context)
+        {
+            context.Append((char)0x18);
+            return default;
+        }
+    }
+    public sealed class x19Transcriber
+    {
+        private x19Transcriber()
+        {
+        }
+
+        public static x19Transcriber Instance { get; } = new x19Transcriber();
+
+        public Void Transcribe(x19 node, StringBuilder context)
+        {
+            context.Append((char)0x19);
+            return default;
+        }
+    }
+    public sealed class x1ATranscriber
+    {
+        private x1ATranscriber()
+        {
+        }
+
+        public static x1ATranscriber Instance { get; } = new x1ATranscriber();
+
+        public Void Transcribe(x1A node, StringBuilder context)
+        {
+            context.Append((char)0x1A);
+            return default;
+        }
+    }
+    public sealed class x1BTranscriber
+    {
+        private x1BTranscriber()
+        {
+        }
+
+        public static x1BTranscriber Instance { get; } = new x1BTranscriber();
+
+        public Void Transcribe(x1B node, StringBuilder context)
+        {
+            context.Append((char)0x1B);
+            return default;
+        }
+    }
+    public sealed class x1CTranscriber
+    {
+        private x1CTranscriber()
+        {
+        }
+
+        public static x1CTranscriber Instance { get; } = new x1CTranscriber();
+
+        public Void Transcribe(x1C node, StringBuilder context)
+        {
+            context.Append((char)0x1C);
+            return default;
+        }
+    }
+    public sealed class x1DTranscriber
+    {
+        private x1DTranscriber()
+        {
+        }
+
+        public static x1DTranscriber Instance { get; } = new x1DTranscriber();
+
+        public Void Transcribe(x1D node, StringBuilder context)
+        {
+            context.Append((char)0x1D);
+            return default;
+        }
+    }
+    public sealed class x1ETranscriber
+    {
+        private x1ETranscriber()
+        {
+        }
+
+        public static x1ETranscriber Instance { get; } = new x1ETranscriber();
+
+        public Void Transcribe(x1E node, StringBuilder context)
+        {
+            context.Append((char)0x1E);
+            return default;
+        }
+    }
+    public sealed class x1FTranscriber
+    {
+        private x1FTranscriber()
+        {
+        }
+
+        public static x1FTranscriber Instance { get; } = new x1FTranscriber();
+
+        public Void Transcribe(x1F node, StringBuilder context)
+        {
+            context.Append((char)0x1F);
+            return default;
+        }
+    }
+    public sealed class x20Transcriber
+    {
+        private x20Transcriber()
+        {
+        }
+
+        public static x20Transcriber Instance { get; } = new x20Transcriber();
+
+        public Void Transcribe(x20 node, StringBuilder context)
+        {
+            context.Append((char)0x20);
+            return default;
+        }
+    }
+    public sealed class x21Transcriber
+    {
+        private x21Transcriber()
+        {
+        }
+
+        public static x21Transcriber Instance { get; } = new x21Transcriber();
+
+        public Void Transcribe(x21 node, StringBuilder context)
+        {
+            context.Append((char)0x21);
+            return default;
+        }
+    }
+    public sealed class x22Transcriber
+    {
+        private x22Transcriber()
+        {
+        }
+
+        public static x22Transcriber Instance { get; } = new x22Transcriber();
+
+        public Void Transcribe(x22 node, StringBuilder context)
+        {
+            context.Append((char)0x22);
+            return default;
+        }
+    }
+    public sealed class x23Transcriber
+    {
+        private x23Transcriber()
+        {
+        }
+
+        public static x23Transcriber Instance { get; } = new x23Transcriber();
+
+        public Void Transcribe(x23 node, StringBuilder context)
+        {
+            context.Append((char)0x23);
+            return default;
+        }
+    }
+    public sealed class x24Transcriber
+    {
+        private x24Transcriber()
+        {
+        }
+
+        public static x24Transcriber Instance { get; } = new x24Transcriber();
+
+        public Void Transcribe(x24 node, StringBuilder context)
+        {
+            context.Append((char)0x24);
+            return default;
+        }
+    }
+    public sealed class x25Transcriber
+    {
+        private x25Transcriber()
+        {
+        }
+
+        public static x25Transcriber Instance { get; } = new x25Transcriber();
+
+        public Void Transcribe(x25 node, StringBuilder context)
+        {
+            context.Append((char)0x25);
+            return default;
+        }
+    }
+    public sealed class x26Transcriber
+    {
+        private x26Transcriber()
+        {
+        }
+
+        public static x26Transcriber Instance { get; } = new x26Transcriber();
+
+        public Void Transcribe(x26 node, StringBuilder context)
+        {
+            context.Append((char)0x26);
+            return default;
+        }
+    }
+    public sealed class x27Transcriber
+    {
+        private x27Transcriber()
+        {
+        }
+
+        public static x27Transcriber Instance { get; } = new x27Transcriber();
+
+        public Void Transcribe(x27 node, StringBuilder context)
+        {
+            context.Append((char)0x27);
+            return default;
+        }
+    }
+    public sealed class x28Transcriber
+    {
+        private x28Transcriber()
+        {
+        }
+
+        public static x28Transcriber Instance { get; } = new x28Transcriber();
+
+        public Void Transcribe(x28 node, StringBuilder context)
+        {
+            context.Append((char)0x28);
+            return default;
+        }
+    }
+    public sealed class x29Transcriber
+    {
+        private x29Transcriber()
+        {
+        }
+
+        public static x29Transcriber Instance { get; } = new x29Transcriber();
+
+        public Void Transcribe(x29 node, StringBuilder context)
+        {
+            context.Append((char)0x29);
+            return default;
+        }
+    }
+    public sealed class x2ATranscriber
+    {
+        private x2ATranscriber()
+        {
+        }
+
+        public static x2ATranscriber Instance { get; } = new x2ATranscriber();
+
+        public Void Transcribe(x2A node, StringBuilder context)
+        {
+            context.Append((char)0x2A);
+            return default;
+        }
+    }
+    public sealed class x2BTranscriber
+    {
+        private x2BTranscriber()
+        {
+        }
+
+        public static x2BTranscriber Instance { get; } = new x2BTranscriber();
+
+        public Void Transcribe(x2B node, StringBuilder context)
+        {
+            context.Append((char)0x2B);
+            return default;
+        }
+    }
+    public sealed class x2CTranscriber
+    {
+        private x2CTranscriber()
+        {
+        }
+
+        public static x2CTranscriber Instance { get; } = new x2CTranscriber();
+
+        public Void Transcribe(x2C node, StringBuilder context)
+        {
+            context.Append((char)0x2C);
+            return default;
+        }
+    }
+    public sealed class x2DTranscriber
+    {
+        private x2DTranscriber()
+        {
+        }
+
+        public static x2DTranscriber Instance { get; } = new x2DTranscriber();
+
+        public Void Transcribe(x2D node, StringBuilder context)
+        {
+            context.Append((char)0x2D);
+            return default;
+        }
+    }
+    public sealed class x2ETranscriber
+    {
+        private x2ETranscriber()
+        {
+        }
+
+        public static x2ETranscriber Instance { get; } = new x2ETranscriber();
+
+        public Void Transcribe(x2E node, StringBuilder context)
+        {
+            context.Append((char)0x2E);
+            return default;
+        }
+    }
+    public sealed class x2FTranscriber
+    {
+        private x2FTranscriber()
+        {
+        }
+
+        public static x2FTranscriber Instance { get; } = new x2FTranscriber();
+
+        public Void Transcribe(x2F node, StringBuilder context)
+        {
+            context.Append((char)0x2F);
+            return default;
+        }
+    }
+    public sealed class x30Transcriber
+    {
+        private x30Transcriber()
+        {
+        }
+
+        public static x30Transcriber Instance { get; } = new x30Transcriber();
+
+        public Void Transcribe(x30 node, StringBuilder context)
+        {
+            context.Append((char)0x30);
+            return default;
+        }
+    }
+    public sealed class x31Transcriber
+    {
+        private x31Transcriber()
+        {
+        }
+
+        public static x31Transcriber Instance { get; } = new x31Transcriber();
+
+        public Void Transcribe(x31 node, StringBuilder context)
+        {
+            context.Append((char)0x31);
+            return default;
+        }
+    }
+    public sealed class x32Transcriber
+    {
+        private x32Transcriber()
+        {
+        }
+
+        public static x32Transcriber Instance { get; } = new x32Transcriber();
+
+        public Void Transcribe(x32 node, StringBuilder context)
+        {
+            context.Append((char)0x32);
+            return default;
+        }
+    }
+    public sealed class x33Transcriber
+    {
+        private x33Transcriber()
+        {
+        }
+
+        public static x33Transcriber Instance { get; } = new x33Transcriber();
+
+        public Void Transcribe(x33 node, StringBuilder context)
+        {
+            context.Append((char)0x33);
+            return default;
+        }
+    }
+    public sealed class x34Transcriber
+    {
+        private x34Transcriber()
+        {
+        }
+
+        public static x34Transcriber Instance { get; } = new x34Transcriber();
+
+        public Void Transcribe(x34 node, StringBuilder context)
+        {
+            context.Append((char)0x34);
+            return default;
+        }
+    }
+    public sealed class x35Transcriber
+    {
+        private x35Transcriber()
+        {
+        }
+
+        public static x35Transcriber Instance { get; } = new x35Transcriber();
+
+        public Void Transcribe(x35 node, StringBuilder context)
+        {
+            context.Append((char)0x35);
+            return default;
+        }
+    }
+    public sealed class x36Transcriber
+    {
+        private x36Transcriber()
+        {
+        }
+
+        public static x36Transcriber Instance { get; } = new x36Transcriber();
+
+        public Void Transcribe(x36 node, StringBuilder context)
+        {
+            context.Append((char)0x36);
+            return default;
+        }
+    }
+    public sealed class x37Transcriber
+    {
+        private x37Transcriber()
+        {
+        }
+
+        public static x37Transcriber Instance { get; } = new x37Transcriber();
+
+        public Void Transcribe(x37 node, StringBuilder context)
+        {
+            context.Append((char)0x37);
+            return default;
+        }
+    }
+    public sealed class x38Transcriber
+    {
+        private x38Transcriber()
+        {
+        }
+
+        public static x38Transcriber Instance { get; } = new x38Transcriber();
+
+        public Void Transcribe(x38 node, StringBuilder context)
+        {
+            context.Append((char)0x38);
+            return default;
+        }
+    }
+    public sealed class x39Transcriber
+    {
+        private x39Transcriber()
+        {
+        }
+
+        public static x39Transcriber Instance { get; } = new x39Transcriber();
+
+        public Void Transcribe(x39 node, StringBuilder context)
+        {
+            context.Append((char)0x39);
+            return default;
+        }
+    }
+    public sealed class x3ATranscriber
+    {
+        private x3ATranscriber()
+        {
+        }
+
+        public static x3ATranscriber Instance { get; } = new x3ATranscriber();
+
+        public Void Transcribe(x3A node, StringBuilder context)
+        {
+            context.Append((char)0x3A);
+            return default;
+        }
+    }
+    public sealed class x3BTranscriber
+    {
+        private x3BTranscriber()
+        {
+        }
+
+        public static x3BTranscriber Instance { get; } = new x3BTranscriber();
+
+        public Void Transcribe(x3B node, StringBuilder context)
+        {
+            context.Append((char)0x3B);
+            return default;
+        }
+    }
+    public sealed class x3CTranscriber
+    {
+        private x3CTranscriber()
+        {
+        }
+
+        public static x3CTranscriber Instance { get; } = new x3CTranscriber();
+
+        public Void Transcribe(x3C node, StringBuilder context)
+        {
+            context.Append((char)0x3C);
+            return default;
+        }
+    }
+    public sealed class x3DTranscriber
+    {
+        private x3DTranscriber()
+        {
+        }
+
+        public static x3DTranscriber Instance { get; } = new x3DTranscriber();
+
+        public Void Transcribe(x3D node, StringBuilder context)
+        {
+            context.Append((char)0x3D);
+            return default;
+        }
+    }
+    public sealed class x3ETranscriber
+    {
+        private x3ETranscriber()
+        {
+        }
+
+        public static x3ETranscriber Instance { get; } = new x3ETranscriber();
+
+        public Void Transcribe(x3E node, StringBuilder context)
+        {
+            context.Append((char)0x3E);
+            return default;
+        }
+    }
+    public sealed class x3FTranscriber
+    {
+        private x3FTranscriber()
+        {
+        }
+
+        public static x3FTranscriber Instance { get; } = new x3FTranscriber();
+
+        public Void Transcribe(x3F node, StringBuilder context)
+        {
+            context.Append((char)0x3F);
+            return default;
+        }
+    }
+    public sealed class x40Transcriber
+    {
+        private x40Transcriber()
+        {
+        }
+
+        public static x40Transcriber Instance { get; } = new x40Transcriber();
+
+        public Void Transcribe(x40 node, StringBuilder context)
+        {
+            context.Append((char)0x40);
+            return default;
+        }
+    }
+    public sealed class x41Transcriber
+    {
+        private x41Transcriber()
+        {
+        }
+
+        public static x41Transcriber Instance { get; } = new x41Transcriber();
+
+        public Void Transcribe(x41 node, StringBuilder context)
+        {
+            context.Append((char)0x41);
+            return default;
+        }
+    }
+    public sealed class x42Transcriber
+    {
+        private x42Transcriber()
+        {
+        }
+
+        public static x42Transcriber Instance { get; } = new x42Transcriber();
+
+        public Void Transcribe(x42 node, StringBuilder context)
+        {
+            context.Append((char)0x42);
+            return default;
+        }
+    }
+    public sealed class x43Transcriber
+    {
+        private x43Transcriber()
+        {
+        }
+
+        public static x43Transcriber Instance { get; } = new x43Transcriber();
+
+        public Void Transcribe(x43 node, StringBuilder context)
+        {
+            context.Append((char)0x43);
+            return default;
+        }
+    }
+    public sealed class x44Transcriber
+    {
+        private x44Transcriber()
+        {
+        }
+
+        public static x44Transcriber Instance { get; } = new x44Transcriber();
+
+        public Void Transcribe(x44 node, StringBuilder context)
+        {
+            context.Append((char)0x44);
+            return default;
+        }
+    }
+    public sealed class x45Transcriber
+    {
+        private x45Transcriber()
+        {
+        }
+
+        public static x45Transcriber Instance { get; } = new x45Transcriber();
+
+        public Void Transcribe(x45 node, StringBuilder context)
+        {
+            context.Append((char)0x45);
+            return default;
+        }
+    }
+    public sealed class x46Transcriber
+    {
+        private x46Transcriber()
+        {
+        }
+
+        public static x46Transcriber Instance { get; } = new x46Transcriber();
+
+        public Void Transcribe(x46 node, StringBuilder context)
+        {
+            context.Append((char)0x46);
+            return default;
+        }
+    }
+    public sealed class x47Transcriber
+    {
+        private x47Transcriber()
+        {
+        }
+
+        public static x47Transcriber Instance { get; } = new x47Transcriber();
+
+        public Void Transcribe(x47 node, StringBuilder context)
+        {
+            context.Append((char)0x47);
+            return default;
+        }
+    }
+    public sealed class x48Transcriber
+    {
+        private x48Transcriber()
+        {
+        }
+
+        public static x48Transcriber Instance { get; } = new x48Transcriber();
+
+        public Void Transcribe(x48 node, StringBuilder context)
+        {
+            context.Append((char)0x48);
+            return default;
+        }
+    }
+    public sealed class x49Transcriber
+    {
+        private x49Transcriber()
+        {
+        }
+
+        public static x49Transcriber Instance { get; } = new x49Transcriber();
+
+        public Void Transcribe(x49 node, StringBuilder context)
+        {
+            context.Append((char)0x49);
+            return default;
+        }
+    }
+    public sealed class x4ATranscriber
+    {
+        private x4ATranscriber()
+        {
+        }
+
+        public static x4ATranscriber Instance { get; } = new x4ATranscriber();
+
+        public Void Transcribe(x4A node, StringBuilder context)
+        {
+            context.Append((char)0x4A);
+            return default;
+        }
+    }
+    public sealed class x4BTranscriber
+    {
+        private x4BTranscriber()
+        {
+        }
+
+        public static x4BTranscriber Instance { get; } = new x4BTranscriber();
+
+        public Void Transcribe(x4B node, StringBuilder context)
+        {
+            context.Append((char)0x4B);
+            return default;
+        }
+    }
+    public sealed class x4CTranscriber
+    {
+        private x4CTranscriber()
+        {
+        }
+
+        public static x4CTranscriber Instance { get; } = new x4CTranscriber();
+
+        public Void Transcribe(x4C node, StringBuilder context)
+        {
+            context.Append((char)0x4C);
+            return default;
+        }
+    }
+    public sealed class x4DTranscriber
+    {
+        private x4DTranscriber()
+        {
+        }
+
+        public static x4DTranscriber Instance { get; } = new x4DTranscriber();
+
+        public Void Transcribe(x4D node, StringBuilder context)
+        {
+            context.Append((char)0x4D);
+            return default;
+        }
+    }
+    public sealed class x4ETranscriber
+    {
+        private x4ETranscriber()
+        {
+        }
+
+        public static x4ETranscriber Instance { get; } = new x4ETranscriber();
+
+        public Void Transcribe(x4E node, StringBuilder context)
+        {
+            context.Append((char)0x4E);
+            return default;
+        }
+    }
+    public sealed class x4FTranscriber
+    {
+        private x4FTranscriber()
+        {
+        }
+
+        public static x4FTranscriber Instance { get; } = new x4FTranscriber();
+
+        public Void Transcribe(x4F node, StringBuilder context)
+        {
+            context.Append((char)0x4F);
+            return default;
+        }
+    }
+    public sealed class x50Transcriber
+    {
+        private x50Transcriber()
+        {
+        }
+
+        public static x50Transcriber Instance { get; } = new x50Transcriber();
+
+        public Void Transcribe(x50 node, StringBuilder context)
+        {
+            context.Append((char)0x50);
+            return default;
+        }
+    }
+    public sealed class x51Transcriber
+    {
+        private x51Transcriber()
+        {
+        }
+
+        public static x51Transcriber Instance { get; } = new x51Transcriber();
+
+        public Void Transcribe(x51 node, StringBuilder context)
+        {
+            context.Append((char)0x51);
+            return default;
+        }
+    }
+    public sealed class x52Transcriber
+    {
+        private x52Transcriber()
+        {
+        }
+
+        public static x52Transcriber Instance { get; } = new x52Transcriber();
+
+        public Void Transcribe(x52 node, StringBuilder context)
+        {
+            context.Append((char)0x52);
+            return default;
+        }
+    }
+    public sealed class x53Transcriber
+    {
+        private x53Transcriber()
+        {
+        }
+
+        public static x53Transcriber Instance { get; } = new x53Transcriber();
+
+        public Void Transcribe(x53 node, StringBuilder context)
+        {
+            context.Append((char)0x53);
+            return default;
+        }
+    }
+    public sealed class x54Transcriber
+    {
+        private x54Transcriber()
+        {
+        }
+
+        public static x54Transcriber Instance { get; } = new x54Transcriber();
+
+        public Void Transcribe(x54 node, StringBuilder context)
+        {
+            context.Append((char)0x54);
+            return default;
+        }
+    }
+    public sealed class x55Transcriber
+    {
+        private x55Transcriber()
+        {
+        }
+
+        public static x55Transcriber Instance { get; } = new x55Transcriber();
+
+        public Void Transcribe(x55 node, StringBuilder context)
+        {
+            context.Append((char)0x55);
+            return default;
+        }
+    }
+    public sealed class x56Transcriber
+    {
+        private x56Transcriber()
+        {
+        }
+
+        public static x56Transcriber Instance { get; } = new x56Transcriber();
+
+        public Void Transcribe(x56 node, StringBuilder context)
+        {
+            context.Append((char)0x56);
+            return default;
+        }
+    }
+    public sealed class x57Transcriber
+    {
+        private x57Transcriber()
+        {
+        }
+
+        public static x57Transcriber Instance { get; } = new x57Transcriber();
+
+        public Void Transcribe(x57 node, StringBuilder context)
+        {
+            context.Append((char)0x57);
+            return default;
+        }
+    }
+    public sealed class x58Transcriber
+    {
+        private x58Transcriber()
+        {
+        }
+
+        public static x58Transcriber Instance { get; } = new x58Transcriber();
+
+        public Void Transcribe(x58 node, StringBuilder context)
+        {
+            context.Append((char)0x58);
+            return default;
+        }
+    }
+    public sealed class x59Transcriber
+    {
+        private x59Transcriber()
+        {
+        }
+
+        public static x59Transcriber Instance { get; } = new x59Transcriber();
+
+        public Void Transcribe(x59 node, StringBuilder context)
+        {
+            context.Append((char)0x59);
+            return default;
+        }
+    }
+    public sealed class x5ATranscriber
+    {
+        private x5ATranscriber()
+        {
+        }
+
+        public static x5ATranscriber Instance { get; } = new x5ATranscriber();
+
+        public Void Transcribe(x5A node, StringBuilder context)
+        {
+            context.Append((char)0x5A);
+            return default;
+        }
+    }
+    public sealed class x5BTranscriber
+    {
+        private x5BTranscriber()
+        {
+        }
+
+        public static x5BTranscriber Instance { get; } = new x5BTranscriber();
+
+        public Void Transcribe(x5B node, StringBuilder context)
+        {
+            context.Append((char)0x5B);
+            return default;
+        }
+    }
+    public sealed class x5CTranscriber
+    {
+        private x5CTranscriber()
+        {
+        }
+
+        public static x5CTranscriber Instance { get; } = new x5CTranscriber();
+
+        public Void Transcribe(x5C node, StringBuilder context)
+        {
+            context.Append((char)0x5C);
+            return default;
+        }
+    }
+    public sealed class x5DTranscriber
+    {
+        private x5DTranscriber()
+        {
+        }
+
+        public static x5DTranscriber Instance { get; } = new x5DTranscriber();
+
+        public Void Transcribe(x5D node, StringBuilder context)
+        {
+            context.Append((char)0x5D);
+            return default;
+        }
+    }
+    public sealed class x5ETranscriber
+    {
+        private x5ETranscriber()
+        {
+        }
+
+        public static x5ETranscriber Instance { get; } = new x5ETranscriber();
+
+        public Void Transcribe(x5E node, StringBuilder context)
+        {
+            context.Append((char)0x5E);
+            return default;
+        }
+    }
+    public sealed class x5FTranscriber
+    {
+        private x5FTranscriber()
+        {
+        }
+
+        public static x5FTranscriber Instance { get; } = new x5FTranscriber();
+
+        public Void Transcribe(x5F node, StringBuilder context)
+        {
+            context.Append((char)0x5F);
+            return default;
+        }
+    }
+    public sealed class x60Transcriber
+    {
+        private x60Transcriber()
+        {
+        }
+
+        public static x60Transcriber Instance { get; } = new x60Transcriber();
+
+        public Void Transcribe(x60 node, StringBuilder context)
+        {
+            context.Append((char)0x60);
+            return default;
+        }
+    }
+    public sealed class x61Transcriber
+    {
+        private x61Transcriber()
+        {
+        }
+
+        public static x61Transcriber Instance { get; } = new x61Transcriber();
+
+        public Void Transcribe(x61 node, StringBuilder context)
+        {
+            context.Append((char)0x61);
+            return default;
+        }
+    }
+    public sealed class x62Transcriber
+    {
+        private x62Transcriber()
+        {
+        }
+
+        public static x62Transcriber Instance { get; } = new x62Transcriber();
+
+        public Void Transcribe(x62 node, StringBuilder context)
+        {
+            context.Append((char)0x62);
+            return default;
+        }
+    }
+    public sealed class x63Transcriber
+    {
+        private x63Transcriber()
+        {
+        }
+
+        public static x63Transcriber Instance { get; } = new x63Transcriber();
+
+        public Void Transcribe(x63 node, StringBuilder context)
+        {
+            context.Append((char)0x63);
+            return default;
+        }
+    }
+    public sealed class x64Transcriber
+    {
+        private x64Transcriber()
+        {
+        }
+
+        public static x64Transcriber Instance { get; } = new x64Transcriber();
+
+        public Void Transcribe(x64 node, StringBuilder context)
+        {
+            context.Append((char)0x64);
+            return default;
+        }
+    }
+    public sealed class x65Transcriber
+    {
+        private x65Transcriber()
+        {
+        }
+
+        public static x65Transcriber Instance { get; } = new x65Transcriber();
+
+        public Void Transcribe(x65 node, StringBuilder context)
+        {
+            context.Append((char)0x65);
+            return default;
+        }
+    }
+    public sealed class x66Transcriber
+    {
+        private x66Transcriber()
+        {
+        }
+
+        public static x66Transcriber Instance { get; } = new x66Transcriber();
+
+        public Void Transcribe(x66 node, StringBuilder context)
+        {
+            context.Append((char)0x66);
+            return default;
+        }
+    }
+    public sealed class x67Transcriber
+    {
+        private x67Transcriber()
+        {
+        }
+
+        public static x67Transcriber Instance { get; } = new x67Transcriber();
+
+        public Void Transcribe(x67 node, StringBuilder context)
+        {
+            context.Append((char)0x67);
+            return default;
+        }
+    }
+    public sealed class x68Transcriber
+    {
+        private x68Transcriber()
+        {
+        }
+
+        public static x68Transcriber Instance { get; } = new x68Transcriber();
+
+        public Void Transcribe(x68 node, StringBuilder context)
+        {
+            context.Append((char)0x68);
+            return default;
+        }
+    }
+    public sealed class x69Transcriber
+    {
+        private x69Transcriber()
+        {
+        }
+
+        public static x69Transcriber Instance { get; } = new x69Transcriber();
+
+        public Void Transcribe(x69 node, StringBuilder context)
+        {
+            context.Append((char)0x69);
+            return default;
+        }
+    }
+    public sealed class x6ATranscriber
+    {
+        private x6ATranscriber()
+        {
+        }
+
+        public static x6ATranscriber Instance { get; } = new x6ATranscriber();
+
+        public Void Transcribe(x6A node, StringBuilder context)
+        {
+            context.Append((char)0x6A);
+            return default;
+        }
+    }
+    public sealed class x6BTranscriber
+    {
+        private x6BTranscriber()
+        {
+        }
+
+        public static x6BTranscriber Instance { get; } = new x6BTranscriber();
+
+        public Void Transcribe(x6B node, StringBuilder context)
+        {
+            context.Append((char)0x6B);
+            return default;
+        }
+    }
+    public sealed class x6CTranscriber
+    {
+        private x6CTranscriber()
+        {
+        }
+
+        public static x6CTranscriber Instance { get; } = new x6CTranscriber();
+
+        public Void Transcribe(x6C node, StringBuilder context)
+        {
+            context.Append((char)0x6C);
+            return default;
+        }
+    }
+    public sealed class x6DTranscriber
+    {
+        private x6DTranscriber()
+        {
+        }
+
+        public static x6DTranscriber Instance { get; } = new x6DTranscriber();
+
+        public Void Transcribe(x6D node, StringBuilder context)
+        {
+            context.Append((char)0x6D);
+            return default;
+        }
+    }
+    public sealed class x6ETranscriber
+    {
+        private x6ETranscriber()
+        {
+        }
+
+        public static x6ETranscriber Instance { get; } = new x6ETranscriber();
+
+        public Void Transcribe(x6E node, StringBuilder context)
+        {
+            context.Append((char)0x6E);
+            return default;
+        }
+    }
+    public sealed class x6FTranscriber
+    {
+        private x6FTranscriber()
+        {
+        }
+
+        public static x6FTranscriber Instance { get; } = new x6FTranscriber();
+
+        public Void Transcribe(x6F node, StringBuilder context)
+        {
+            context.Append((char)0x6F);
+            return default;
+        }
+    }
+    public sealed class x70Transcriber
+    {
+        private x70Transcriber()
+        {
+        }
+
+        public static x70Transcriber Instance { get; } = new x70Transcriber();
+
+        public Void Transcribe(x70 node, StringBuilder context)
+        {
+            context.Append((char)0x70);
+            return default;
+        }
+    }
+    public sealed class x71Transcriber
+    {
+        private x71Transcriber()
+        {
+        }
+
+        public static x71Transcriber Instance { get; } = new x71Transcriber();
+
+        public Void Transcribe(x71 node, StringBuilder context)
+        {
+            context.Append((char)0x71);
+            return default;
+        }
+    }
+    public sealed class x72Transcriber
+    {
+        private x72Transcriber()
+        {
+        }
+
+        public static x72Transcriber Instance { get; } = new x72Transcriber();
+
+        public Void Transcribe(x72 node, StringBuilder context)
+        {
+            context.Append((char)0x72);
+            return default;
+        }
+    }
+    public sealed class x73Transcriber
+    {
+        private x73Transcriber()
+        {
+        }
+
+        public static x73Transcriber Instance { get; } = new x73Transcriber();
+
+        public Void Transcribe(x73 node, StringBuilder context)
+        {
+            context.Append((char)0x73);
+            return default;
+        }
+    }
+    public sealed class x74Transcriber
+    {
+        private x74Transcriber()
+        {
+        }
+
+        public static x74Transcriber Instance { get; } = new x74Transcriber();
+
+        public Void Transcribe(x74 node, StringBuilder context)
+        {
+            context.Append((char)0x74);
+            return default;
+        }
+    }
+    public sealed class x75Transcriber
+    {
+        private x75Transcriber()
+        {
+        }
+
+        public static x75Transcriber Instance { get; } = new x75Transcriber();
+
+        public Void Transcribe(x75 node, StringBuilder context)
+        {
+            context.Append((char)0x75);
+            return default;
+        }
+    }
+    public sealed class x76Transcriber
+    {
+        private x76Transcriber()
+        {
+        }
+
+        public static x76Transcriber Instance { get; } = new x76Transcriber();
+
+        public Void Transcribe(x76 node, StringBuilder context)
+        {
+            context.Append((char)0x76);
+            return default;
+        }
+    }
+    public sealed class x77Transcriber
+    {
+        private x77Transcriber()
+        {
+        }
+
+        public static x77Transcriber Instance { get; } = new x77Transcriber();
+
+        public Void Transcribe(x77 node, StringBuilder context)
+        {
+            context.Append((char)0x77);
+            return default;
+        }
+    }
+    public sealed class x78Transcriber
+    {
+        private x78Transcriber()
+        {
+        }
+
+        public static x78Transcriber Instance { get; } = new x78Transcriber();
+
+        public Void Transcribe(x78 node, StringBuilder context)
+        {
+            context.Append((char)0x78);
+            return default;
+        }
+    }
+    public sealed class x79Transcriber
+    {
+        private x79Transcriber()
+        {
+        }
+
+        public static x79Transcriber Instance { get; } = new x79Transcriber();
+
+        public Void Transcribe(x79 node, StringBuilder context)
+        {
+            context.Append((char)0x79);
+            return default;
+        }
+    }
+    public sealed class x7ATranscriber
+    {
+        private x7ATranscriber()
+        {
+        }
+
+        public static x7ATranscriber Instance { get; } = new x7ATranscriber();
+
+        public Void Transcribe(x7A node, StringBuilder context)
+        {
+            context.Append((char)0x7A);
+            return default;
+        }
+    }
+    public sealed class x7BTranscriber
+    {
+        private x7BTranscriber()
+        {
+        }
+
+        public static x7BTranscriber Instance { get; } = new x7BTranscriber();
+
+        public Void Transcribe(x7B node, StringBuilder context)
+        {
+            context.Append((char)0x7B);
+            return default;
+        }
+    }
+    public sealed class x7CTranscriber
+    {
+        private x7CTranscriber()
+        {
+        }
+
+        public static x7CTranscriber Instance { get; } = new x7CTranscriber();
+
+        public Void Transcribe(x7C node, StringBuilder context)
+        {
+            context.Append((char)0x7C);
+            return default;
+        }
+    }
+    public sealed class x7DTranscriber
+    {
+        private x7DTranscriber()
+        {
+        }
+
+        public static x7DTranscriber Instance { get; } = new x7DTranscriber();
+
+        public Void Transcribe(x7D node, StringBuilder context)
+        {
+            context.Append((char)0x7D);
+            return default;
+        }
+    }
+    public sealed class x7ETranscriber
+    {
+        private x7ETranscriber()
+        {
+        }
+
+        public static x7ETranscriber Instance { get; } = new x7ETranscriber();
+
+        public Void Transcribe(x7E node, StringBuilder context)
+        {
+            context.Append((char)0x7E);
+            return default;
+        }
+    }
+    public sealed class x7FTranscriber
+    {
+        private x7FTranscriber()
+        {
+        }
+
+        public static x7FTranscriber Instance { get; } = new x7FTranscriber();
+
+        public Void Transcribe(x7F node, StringBuilder context)
+        {
+            context.Append((char)0x7F);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/CrTranscriber.cs b/odata/AbnfParser/Transcribers/Core/CrTranscriber.cs
new file mode 100644
index 0000000000..376f6c09d5
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/CrTranscriber.cs
@@ -0,0 +1,22 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class CrTranscriber
+    {
+        private CrTranscriber()
+        {
+        }
+
+        public static CrTranscriber Instance { get; } = new CrTranscriber();
+
+        public Void Transcribe(Cr node, StringBuilder context)
+        {
+            x0DTranscriber.Instance.Transcribe(node.X0D, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/CrlfTranscriber.cs b/odata/AbnfParser/Transcribers/Core/CrlfTranscriber.cs
new file mode 100644
index 0000000000..74f280517b
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/CrlfTranscriber.cs
@@ -0,0 +1,23 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class CrlfTranscriber
+    {
+        private CrlfTranscriber()
+        {
+        }
+
+        public static CrlfTranscriber Instance { get; } = new CrlfTranscriber();
+
+        public Void Transcribe(Crlf node, StringBuilder context)
+        {
+            CrTranscriber.Instance.Transcribe(node.Cr, context);
+            LfTranscriber.Instance.Transcribe(node.Lf, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/DigitTranscriber.cs b/odata/AbnfParser/Transcribers/Core/DigitTranscriber.cs
new file mode 100644
index 0000000000..4ae71fbd2e
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/DigitTranscriber.cs
@@ -0,0 +1,66 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class DigitTranscriber : Digit.Visitor<Void, StringBuilder>
+    {
+        private DigitTranscriber()
+        {
+        }
+
+        public static DigitTranscriber Instance { get; } = new DigitTranscriber();
+
+        protected internal override Void Accept(Digit.x30 node, StringBuilder context)
+        {
+            return x30Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x31 node, StringBuilder context)
+        {
+            return x31Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x32 node, StringBuilder context)
+        {
+            return x32Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x33 node, StringBuilder context)
+        {
+            return x33Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x34 node, StringBuilder context)
+        {
+            return x34Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x35 node, StringBuilder context)
+        {
+            return x35Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x36 node, StringBuilder context)
+        {
+            return x36Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x37 node, StringBuilder context)
+        {
+            return x37Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x38 node, StringBuilder context)
+        {
+            return x38Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Digit.x39 node, StringBuilder context)
+        {
+            return x39Transcriber.Instance.Transcribe(node.Value, context);
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/DquoteTranscriber.cs b/odata/AbnfParser/Transcribers/Core/DquoteTranscriber.cs
new file mode 100644
index 0000000000..560466e624
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/DquoteTranscriber.cs
@@ -0,0 +1,22 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class DquoteTranscriber
+    {
+        private DquoteTranscriber()
+        {
+        }
+
+        public static DquoteTranscriber Instance { get; } = new DquoteTranscriber();
+
+        public Void Transcribe(Dquote node, StringBuilder context)
+        {
+            x22Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/HexDigTranscriber.cs b/odata/AbnfParser/Transcribers/Core/HexDigTranscriber.cs
new file mode 100644
index 0000000000..395e6b7078
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/HexDigTranscriber.cs
@@ -0,0 +1,57 @@
+using AbnfParser.CstNodes.Core;
+using Root;
+using System.Text;
+
+namespace AbnfParser.Transcribers.Core
+{
+    public sealed class HexDigTranscriber : HexDig.Visitor<Void, StringBuilder>
+    {
+        private HexDigTranscriber()
+        {
+        }
+
+        public static HexDigTranscriber Instance { get; } = new HexDigTranscriber();
+
+        protected internal override Void Accept(HexDig.Digit node, StringBuilder context)
+        {
+            DigitTranscriber.Instance.Visit(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(HexDig.A node, StringBuilder context)
+        {
+            x41Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(HexDig.B node, StringBuilder context)
+        {
+            x42Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(HexDig.C node, StringBuilder context)
+        {
+            x43Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(HexDig.D node, StringBuilder context)
+        {
+            x44Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(HexDig.E node, StringBuilder context)
+        {
+            x45Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(HexDig.F node, StringBuilder context)
+        {
+            x46Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/HtabTranscriber.cs b/odata/AbnfParser/Transcribers/Core/HtabTranscriber.cs
new file mode 100644
index 0000000000..cb6366f701
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/HtabTranscriber.cs
@@ -0,0 +1,22 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class HtabTranscriber
+    {
+        private HtabTranscriber()
+        {
+        }
+
+        public static HtabTranscriber Instance { get; } = new HtabTranscriber();
+
+        public Void Transcribe(Htab node, StringBuilder context)
+        {
+            x09Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/LfTranscriber.cs b/odata/AbnfParser/Transcribers/Core/LfTranscriber.cs
new file mode 100644
index 0000000000..4b9dc2750a
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/LfTranscriber.cs
@@ -0,0 +1,22 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class LfTranscriber
+    {
+        private LfTranscriber()
+        {
+        }
+
+        public static LfTranscriber Instance { get; } = new LfTranscriber();
+
+        public Void Transcribe(Lf node, StringBuilder context)
+        {
+            x0ATranscriber.Instance.Transcribe(node.X0A, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/SpTranscriber.cs b/odata/AbnfParser/Transcribers/Core/SpTranscriber.cs
new file mode 100644
index 0000000000..96f9cbd8bb
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/SpTranscriber.cs
@@ -0,0 +1,22 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class SpTranscriber
+    {
+        private SpTranscriber()
+        {
+        }
+
+        public static SpTranscriber Instance { get; } = new SpTranscriber();
+
+        public Void Transcribe(Sp node, StringBuilder context)
+        {
+            x20Transcriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/VcharTranscriber.cs b/odata/AbnfParser/Transcribers/Core/VcharTranscriber.cs
new file mode 100644
index 0000000000..794bbb9358
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/VcharTranscriber.cs
@@ -0,0 +1,486 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class VcharTranscriber : Vchar.Visitor<Void, StringBuilder>
+    {
+        private VcharTranscriber()
+        {
+        }
+
+        public static VcharTranscriber Instance { get; } = new VcharTranscriber();
+
+        protected internal override Void Accept(Vchar.x21 node, StringBuilder context)
+        {
+            return x21Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x22 node, StringBuilder context)
+        {
+            return x22Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x23 node, StringBuilder context)
+        {
+            return x23Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x24 node, StringBuilder context)
+        {
+            return x24Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x25 node, StringBuilder context)
+        {
+            return x25Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x26 node, StringBuilder context)
+        {
+            return x26Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x27 node, StringBuilder context)
+        {
+            return x27Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x28 node, StringBuilder context)
+        {
+            return x28Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x29 node, StringBuilder context)
+        {
+            return x29Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x2A node, StringBuilder context)
+        {
+            return x2ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x2B node, StringBuilder context)
+        {
+            return x2BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x2C node, StringBuilder context)
+        {
+            return x2CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x2D node, StringBuilder context)
+        {
+            return x2DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x2E node, StringBuilder context)
+        {
+            return x2ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x2F node, StringBuilder context)
+        {
+            return x2FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x30 node, StringBuilder context)
+        {
+            return x30Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x31 node, StringBuilder context)
+        {
+            return x31Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x32 node, StringBuilder context)
+        {
+            return x32Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x33 node, StringBuilder context)
+        {
+            return x33Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x34 node, StringBuilder context)
+        {
+            return x34Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x35 node, StringBuilder context)
+        {
+            return x35Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x36 node, StringBuilder context)
+        {
+            return x36Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x37 node, StringBuilder context)
+        {
+            return x37Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x38 node, StringBuilder context)
+        {
+            return x38Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x39 node, StringBuilder context)
+        {
+            return x39Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x3A node, StringBuilder context)
+        {
+            return x3ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x3B node, StringBuilder context)
+        {
+            return x3BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x3C node, StringBuilder context)
+        {
+            return x3CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x3D node, StringBuilder context)
+        {
+            return x3DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x3E node, StringBuilder context)
+        {
+            return x3ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x3F node, StringBuilder context)
+        {
+            return x3FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x40 node, StringBuilder context)
+        {
+            return x40Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x41 node, StringBuilder context)
+        {
+            return x41Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x42 node, StringBuilder context)
+        {
+            return x42Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x43 node, StringBuilder context)
+        {
+            return x43Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x44 node, StringBuilder context)
+        {
+            return x44Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x45 node, StringBuilder context)
+        {
+            return x45Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x46 node, StringBuilder context)
+        {
+            return x46Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x47 node, StringBuilder context)
+        {
+            return x47Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x48 node, StringBuilder context)
+        {
+            return x48Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x49 node, StringBuilder context)
+        {
+            return x49Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x4A node, StringBuilder context)
+        {
+            return x4ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x4B node, StringBuilder context)
+        {
+            return x4BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x4C node, StringBuilder context)
+        {
+            return x4CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x4D node, StringBuilder context)
+        {
+            return x4DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x4E node, StringBuilder context)
+        {
+            return x4ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x4F node, StringBuilder context)
+        {
+            return x4FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x50 node, StringBuilder context)
+        {
+            return x50Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x51 node, StringBuilder context)
+        {
+            return x51Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x52 node, StringBuilder context)
+        {
+            return x52Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x53 node, StringBuilder context)
+        {
+            return x53Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x54 node, StringBuilder context)
+        {
+            return x54Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x55 node, StringBuilder context)
+        {
+            return x55Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x56 node, StringBuilder context)
+        {
+            return x56Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x57 node, StringBuilder context)
+        {
+            return x57Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x58 node, StringBuilder context)
+        {
+            return x58Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x59 node, StringBuilder context)
+        {
+            return x59Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x5A node, StringBuilder context)
+        {
+            return x5ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x5B node, StringBuilder context)
+        {
+            return x5BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x5C node, StringBuilder context)
+        {
+            return x5CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x5D node, StringBuilder context)
+        {
+            return x5DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x5E node, StringBuilder context)
+        {
+            return x5ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x5F node, StringBuilder context)
+        {
+            return x5FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x60 node, StringBuilder context)
+        {
+            return x60Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x61 node, StringBuilder context)
+        {
+            return x61Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x62 node, StringBuilder context)
+        {
+            return x62Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x63 node, StringBuilder context)
+        {
+            return x63Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x64 node, StringBuilder context)
+        {
+            return x64Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x65 node, StringBuilder context)
+        {
+            return x65Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x66 node, StringBuilder context)
+        {
+            return x66Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x67 node, StringBuilder context)
+        {
+            return x67Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x68 node, StringBuilder context)
+        {
+            return x68Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x69 node, StringBuilder context)
+        {
+            return x69Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x6A node, StringBuilder context)
+        {
+            return x6ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x6B node, StringBuilder context)
+        {
+            return x6BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x6C node, StringBuilder context)
+        {
+            return x6CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x6D node, StringBuilder context)
+        {
+            return x6DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x6E node, StringBuilder context)
+        {
+            return x6ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x6F node, StringBuilder context)
+        {
+            return x6FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x70 node, StringBuilder context)
+        {
+            return x70Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x71 node, StringBuilder context)
+        {
+            return x71Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x72 node, StringBuilder context)
+        {
+            return x72Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x73 node, StringBuilder context)
+        {
+            return x73Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x74 node, StringBuilder context)
+        {
+            return x74Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x75 node, StringBuilder context)
+        {
+            return x75Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x76 node, StringBuilder context)
+        {
+            return x76Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x77 node, StringBuilder context)
+        {
+            return x77Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x78 node, StringBuilder context)
+        {
+            return x78Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x79 node, StringBuilder context)
+        {
+            return x79Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x7A node, StringBuilder context)
+        {
+            return x7ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x7B node, StringBuilder context)
+        {
+            return x7BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x7C node, StringBuilder context)
+        {
+            return x7CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x7D node, StringBuilder context)
+        {
+            return x7DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(Vchar.x7E node, StringBuilder context)
+        {
+            return x7ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/Core/WspTranscriber.cs b/odata/AbnfParser/Transcribers/Core/WspTranscriber.cs
new file mode 100644
index 0000000000..0e990e0300
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/Core/WspTranscriber.cs
@@ -0,0 +1,28 @@
+namespace AbnfParser.Transcribers.Core
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes.Core;
+    using Root;
+
+    public sealed class WspTranscriber : Wsp.Visitor<Void, StringBuilder>
+    {
+        private WspTranscriber()
+        {
+        }
+
+        public static WspTranscriber Instance { get; } = new WspTranscriber();
+
+        protected internal override Void Accept(Wsp.Space node, StringBuilder context)
+        {
+            SpTranscriber.Instance.Transcribe(node.Sp, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Wsp.Tab node, StringBuilder context)
+        {
+            HtabTranscriber.Instance.Transcribe(node.Htab, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/CwspTranscriber.cs b/odata/AbnfParser/Transcribers/CwspTranscriber.cs
new file mode 100644
index 0000000000..329c2563dc
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/CwspTranscriber.cs
@@ -0,0 +1,30 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class CwspTranscriber : Cwsp.Visitor<Void, StringBuilder>
+    {
+        private CwspTranscriber()
+        {
+        }
+
+        public static CwspTranscriber Instance { get; } = new CwspTranscriber();
+
+        protected internal override Void Accept(Cwsp.WspOnly node, StringBuilder context)
+        {
+            WspTranscriber.Instance.Visit(node.Wsp, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Cwsp.CnlAndWsp node, StringBuilder context)
+        {
+            CnlTranscriber.Instance.Visit(node.Cnl, context);
+            WspTranscriber.Instance.Visit(node.Wsp, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/DecValTranscriber.cs b/odata/AbnfParser/Transcribers/DecValTranscriber.cs
new file mode 100644
index 0000000000..10816788ce
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/DecValTranscriber.cs
@@ -0,0 +1,100 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class DecValTranscriber : DecVal.Visitor<Void, StringBuilder>
+    {
+        private DecValTranscriber()
+        {
+        }
+
+        public static DecValTranscriber Instance { get; } = new DecValTranscriber();
+
+        protected internal override Void Accept(DecVal.DecsOnly node, StringBuilder context)
+        {
+            x64Transcriber.Instance.Transcribe(node.D, context);
+            foreach (var digit in node.Digits)
+            {
+                DigitTranscriber.Instance.Visit(digit, context);
+            }
+
+            return default;
+        }
+
+        protected internal override Void Accept(DecVal.ConcatenatedDecs node, StringBuilder context)
+        {
+            x64Transcriber.Instance.Transcribe(node.D, context);
+            foreach (var digit in node.Digits)
+            {
+                DigitTranscriber.Instance.Visit(digit, context);
+            }
+
+            foreach (var inner in node.Inners)
+            {
+                ConcatenatedDecsInnerTrancriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class ConcatenatedDecsInnerTrancriber
+        {
+            private ConcatenatedDecsInnerTrancriber()
+            {
+            }
+
+            public static ConcatenatedDecsInnerTrancriber Instance { get; } = new ConcatenatedDecsInnerTrancriber();
+
+            public Void Transcribe(DecVal.ConcatenatedDecs.Inner node, StringBuilder context)
+            {
+                x2ETranscriber.Instance.Transcribe(node.Dot, context);
+                foreach (var digit in node.Digits)
+                {
+                    DigitTranscriber.Instance.Visit(digit, context);
+                }
+
+                return default;
+            }
+        }
+
+        protected internal override Void Accept(DecVal.Range node, StringBuilder context)
+        {
+            x64Transcriber.Instance.Transcribe(node.D, context);
+            foreach (var digit in node.Digits)
+            {
+                DigitTranscriber.Instance.Visit(digit, context);
+            }
+
+            foreach (var inner in node.Inners)
+            {
+                RangeInnerTrancriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class RangeInnerTrancriber
+        {
+            private RangeInnerTrancriber()
+            {
+            }
+
+            public static RangeInnerTrancriber Instance { get; } = new RangeInnerTrancriber();
+
+            public Void Transcribe(DecVal.Range.Inner node, StringBuilder context)
+            {
+                x2DTranscriber.Instance.Transcribe(node.Dash, context);
+                foreach (var digit in node.Digits)
+                {
+                    DigitTranscriber.Instance.Visit(digit, context);
+                }
+
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/DefinedAsTranscriber.cs b/odata/AbnfParser/Transcribers/DefinedAsTranscriber.cs
new file mode 100644
index 0000000000..d2f843c653
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/DefinedAsTranscriber.cs
@@ -0,0 +1,50 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class DefinedAsTranscriber : DefinedAs.Visitor<Void, StringBuilder>
+    {
+        private DefinedAsTranscriber()
+        {
+        }
+
+        public static DefinedAsTranscriber Instance { get; } = new DefinedAsTranscriber();
+
+        protected internal override Void Accept(DefinedAs.Declaration node, StringBuilder context)
+        {
+            foreach (var prefixCwsp in node.PrefixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(prefixCwsp, context);
+            }
+
+            x3DTranscriber.Instance.Transcribe(node.Equals, context);
+            foreach (var suffixCwsp in node.SuffixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(suffixCwsp, context);
+            }
+
+            return default;
+        }
+
+        protected internal override Void Accept(DefinedAs.Incremental node, StringBuilder context)
+        {
+            foreach (var prefixCwsp in node.PrefixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(prefixCwsp, context);
+            }
+
+            x3DTranscriber.Instance.Transcribe(node.Equals, context);
+            x2FTranscriber.Instance.Transcribe(node.Slash, context);
+            foreach (var suffixCwsp in node.SuffixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(suffixCwsp, context);
+            }
+
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/ElementTranscriber.cs b/odata/AbnfParser/Transcribers/ElementTranscriber.cs
new file mode 100644
index 0000000000..6e20d3e2ef
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/ElementTranscriber.cs
@@ -0,0 +1,52 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using Root;
+
+    public sealed class ElementTranscriber : Element.Visitor<Void, StringBuilder>
+    {
+        private ElementTranscriber()
+        {
+        }
+
+        public static ElementTranscriber Instance { get; } = new ElementTranscriber();
+
+        protected internal override Void Accept(Element.RuleName node, StringBuilder context)
+        {
+            RuleNameTranscriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Element.Group node, StringBuilder context)
+        {
+            GroupTranscriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Element.Option node, StringBuilder context)
+        {
+            OptionTranscriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Element.CharVal node, StringBuilder context)
+        {
+            CharValTranscriber.Instance.Transcribe(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Element.NumVal node, StringBuilder context)
+        {
+            NumValTranscriber.Instance.Visit(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Element.ProseVal node, StringBuilder context)
+        {
+            ProseValTranscriber.Instance.Visit(node.Value, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/ElementsTranscriber.cs b/odata/AbnfParser/Transcribers/ElementsTranscriber.cs
new file mode 100644
index 0000000000..c19b79856d
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/ElementsTranscriber.cs
@@ -0,0 +1,27 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using Root;
+
+    public sealed class ElementsTranscriber
+    {
+        private ElementsTranscriber()
+        {
+        }
+
+        public static ElementsTranscriber Instance { get; } = new ElementsTranscriber();
+
+        public Void Transcribe(Elements node, StringBuilder context)
+        {
+            AlternationTranscriber.Instance.Transcribe(node.Alternation, context);
+            foreach (var cwsp in node.Cwsps)
+            {
+                CwspTranscriber.Instance.Visit(cwsp, context);
+            }
+
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/GroupTranscriber.cs b/odata/AbnfParser/Transcribers/GroupTranscriber.cs
new file mode 100644
index 0000000000..884e3fd6cc
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/GroupTranscriber.cs
@@ -0,0 +1,37 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class GroupTranscriber
+    {
+        private GroupTranscriber()
+        {
+        }
+
+        public static GroupTranscriber Instance { get; } = new GroupTranscriber();
+
+        public Void Transcribe(Group node, StringBuilder context)
+        {
+            x28Transcriber.Instance.Transcribe(node.OpenParenthesis, context);
+            foreach (var prefixCwsp in node.PrefixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(prefixCwsp, context);
+            }
+
+            AlternationTranscriber.Instance.Transcribe(node.Alternation, context);
+
+            foreach (var suffixCwsp in node.SuffixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(suffixCwsp, context);
+            }
+
+            x29Transcriber.Instance.Transcribe(node.CloseParenthesis, context);
+
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/HexValTranscriber.cs b/odata/AbnfParser/Transcribers/HexValTranscriber.cs
new file mode 100644
index 0000000000..76dad63b08
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/HexValTranscriber.cs
@@ -0,0 +1,100 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class HexValTranscriber : HexVal.Visitor<Void, StringBuilder>
+    {
+        private HexValTranscriber()
+        {
+        }
+
+        public static HexValTranscriber Instance { get; } = new HexValTranscriber();
+
+        protected internal override Void Accept(HexVal.HexOnly node, StringBuilder context)
+        {
+            x78Transcriber.Instance.Transcribe(node.X, context);
+            foreach (var hexDig in node.HexDigs)
+            {
+                HexDigTranscriber.Instance.Visit(hexDig, context);
+            }
+
+            return default;
+        }
+
+        protected internal override Void Accept(HexVal.ConcatenatedHex node, StringBuilder context)
+        {
+            x78Transcriber.Instance.Transcribe(node.X, context);
+            foreach (var hexDig in node.HexDigs)
+            {
+                HexDigTranscriber.Instance.Visit(hexDig, context);
+            }
+
+            foreach (var inner in node.Inners)
+            {
+                ConcatenatedHexInnerTranscriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class ConcatenatedHexInnerTranscriber
+        {
+            private ConcatenatedHexInnerTranscriber()
+            {
+            }
+
+            public static ConcatenatedHexInnerTranscriber Instance { get; } = new ConcatenatedHexInnerTranscriber();
+
+            public Void Transcribe(HexVal.ConcatenatedHex.Inner node, StringBuilder context)
+            {
+                x2ETranscriber.Instance.Transcribe(node.Dot, context);
+                foreach (var hexDig in node.HexDigs)
+                {
+                    HexDigTranscriber.Instance.Visit(hexDig, context);
+                }
+
+                return default;
+            }
+        }
+
+        protected internal override Void Accept(HexVal.Range node, StringBuilder context)
+        {
+            x78Transcriber.Instance.Transcribe(node.X, context);
+            foreach (var hexDig in node.HexDigs)
+            {
+                HexDigTranscriber.Instance.Visit(hexDig, context);
+            }
+
+            foreach (var inner in node.Inners)
+            {
+                RangeInnerTranscriber.Instance.Transcribe(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class RangeInnerTranscriber
+        {
+            private RangeInnerTranscriber()
+            {
+            }
+
+            public static RangeInnerTranscriber Instance { get; } = new RangeInnerTranscriber();
+
+            public Void Transcribe(HexVal.Range.Inner node, StringBuilder context)
+            {
+                x2DTranscriber.Instance.Transcribe(node.Dash, context);
+                foreach (var hexDig in node.HexDigs)
+                {
+                    HexDigTranscriber.Instance.Visit(hexDig, context);
+                }
+
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/NumValTranscriber.cs b/odata/AbnfParser/Transcribers/NumValTranscriber.cs
new file mode 100644
index 0000000000..d81c008d67
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/NumValTranscriber.cs
@@ -0,0 +1,38 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class NumValTranscriber : NumVal.Visitor<Void, StringBuilder>
+    {
+        private NumValTranscriber()
+        {
+        }
+
+        public static NumValTranscriber Instance { get; } = new NumValTranscriber();
+
+        protected internal override Void Accept(NumVal.BinVal node, StringBuilder context)
+        {
+            x25Transcriber.Instance.Transcribe(node.Percent, context);
+            BinValTranscriber.Instance.Visit(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(NumVal.DecVal node, StringBuilder context)
+        {
+            x25Transcriber.Instance.Transcribe(node.Percent, context);
+            DecValTranscriber.Instance.Visit(node.Value, context);
+            return default;
+        }
+
+        protected internal override Void Accept(NumVal.HexVal node, StringBuilder context)
+        {
+            x25Transcriber.Instance.Transcribe(node.Percent, context);
+            HexValTranscriber.Instance.Visit(node.Value, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/OptionTranscriber.cs b/odata/AbnfParser/Transcribers/OptionTranscriber.cs
new file mode 100644
index 0000000000..8d103c645e
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/OptionTranscriber.cs
@@ -0,0 +1,35 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class OptionTranscriber
+    {
+        private OptionTranscriber()
+        {
+        }
+
+        public static OptionTranscriber Instance { get; } = new OptionTranscriber();
+
+        public Void Transcribe(Option node, StringBuilder context)
+        {
+            x5BTranscriber.Instance.Transcribe(node.OpenBracket, context);
+            foreach (var prefixCwsp in node.PrefixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(prefixCwsp, context);
+            }
+
+            AlternationTranscriber.Instance.Transcribe(node.Alternation, context);
+            foreach (var suffixCwsp in node.SuffixCwsps)
+            {
+                CwspTranscriber.Instance.Visit(suffixCwsp, context);
+            }
+
+            x5DTranscriber.Instance.Transcribe(node.CloseBracket, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/ProseValTranscriber.cs b/odata/AbnfParser/Transcribers/ProseValTranscriber.cs
new file mode 100644
index 0000000000..7b3c16dbb6
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/ProseValTranscriber.cs
@@ -0,0 +1,489 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class ProseValTranscriber : ProseVal.Visitor<Void, StringBuilder>
+    {
+        private ProseValTranscriber()
+        {
+        }
+
+        public static ProseValTranscriber Instance { get; } = new ProseValTranscriber();
+
+        protected internal override Void Accept(ProseVal.x20 node, StringBuilder context)
+        {
+            return x20Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x21 node, StringBuilder context)
+        {
+            return x21Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x22 node, StringBuilder context)
+        {
+            return x22Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x23 node, StringBuilder context)
+        {
+            return x23Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x24 node, StringBuilder context)
+        {
+            return x24Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x25 node, StringBuilder context)
+        {
+            return x25Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x26 node, StringBuilder context)
+        {
+            return x26Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x27 node, StringBuilder context)
+        {
+            return x27Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x28 node, StringBuilder context)
+        {
+            return x28Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x29 node, StringBuilder context)
+        {
+            return x29Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x2A node, StringBuilder context)
+        {
+            return x2ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x2B node, StringBuilder context)
+        {
+            return x2BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x2C node, StringBuilder context)
+        {
+            return x2CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x2D node, StringBuilder context)
+        {
+            return x2DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x2E node, StringBuilder context)
+        {
+            return x2ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x2F node, StringBuilder context)
+        {
+            return x2FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x30 node, StringBuilder context)
+        {
+            return x30Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x31 node, StringBuilder context)
+        {
+            return x31Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x32 node, StringBuilder context)
+        {
+            return x32Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x33 node, StringBuilder context)
+        {
+            return x33Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x34 node, StringBuilder context)
+        {
+            return x34Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x35 node, StringBuilder context)
+        {
+            return x35Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x36 node, StringBuilder context)
+        {
+            return x36Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x37 node, StringBuilder context)
+        {
+            return x37Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x38 node, StringBuilder context)
+        {
+            return x38Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x39 node, StringBuilder context)
+        {
+            return x39Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x3A node, StringBuilder context)
+        {
+            return x3ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x3B node, StringBuilder context)
+        {
+            return x3BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x3C node, StringBuilder context)
+        {
+            return x3CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x3D node, StringBuilder context)
+        {
+            return x3DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x3F node, StringBuilder context)
+        {
+            return x3FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x40 node, StringBuilder context)
+        {
+            return x40Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x41 node, StringBuilder context)
+        {
+            return x41Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x42 node, StringBuilder context)
+        {
+            return x42Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x43 node, StringBuilder context)
+        {
+            return x43Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x44 node, StringBuilder context)
+        {
+            return x44Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x45 node, StringBuilder context)
+        {
+            return x45Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x46 node, StringBuilder context)
+        {
+            return x46Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x47 node, StringBuilder context)
+        {
+            return x47Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x48 node, StringBuilder context)
+        {
+            return x48Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x49 node, StringBuilder context)
+        {
+            return x49Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x4A node, StringBuilder context)
+        {
+            return x4ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x4B node, StringBuilder context)
+        {
+            return x4BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x4C node, StringBuilder context)
+        {
+            return x4CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x4D node, StringBuilder context)
+        {
+            return x4DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x4E node, StringBuilder context)
+        {
+            return x4ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x4F node, StringBuilder context)
+        {
+            return x4FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x50 node, StringBuilder context)
+        {
+            return x50Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x51 node, StringBuilder context)
+        {
+            return x51Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x52 node, StringBuilder context)
+        {
+            return x52Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x53 node, StringBuilder context)
+        {
+            return x53Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x54 node, StringBuilder context)
+        {
+            return x54Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x55 node, StringBuilder context)
+        {
+            return x55Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x56 node, StringBuilder context)
+        {
+            return x56Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x57 node, StringBuilder context)
+        {
+            return x57Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x58 node, StringBuilder context)
+        {
+            return x58Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x59 node, StringBuilder context)
+        {
+            return x59Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x5A node, StringBuilder context)
+        {
+            return x5ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x5B node, StringBuilder context)
+        {
+            return x5BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x5C node, StringBuilder context)
+        {
+            return x5CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x5D node, StringBuilder context)
+        {
+            return x5DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x5E node, StringBuilder context)
+        {
+            return x5ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x5F node, StringBuilder context)
+        {
+            return x5FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x60 node, StringBuilder context)
+        {
+            return x60Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x61 node, StringBuilder context)
+        {
+            return x61Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x62 node, StringBuilder context)
+        {
+            return x62Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x63 node, StringBuilder context)
+        {
+            return x63Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x64 node, StringBuilder context)
+        {
+            return x64Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x65 node, StringBuilder context)
+        {
+            return x65Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x66 node, StringBuilder context)
+        {
+            return x66Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x67 node, StringBuilder context)
+        {
+            return x67Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x68 node, StringBuilder context)
+        {
+            return x68Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x69 node, StringBuilder context)
+        {
+            return x69Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x6A node, StringBuilder context)
+        {
+            return x6ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x6B node, StringBuilder context)
+        {
+            return x6BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x6C node, StringBuilder context)
+        {
+            return x6CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x6D node, StringBuilder context)
+        {
+            return x6DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x6E node, StringBuilder context)
+        {
+            return x6ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x6F node, StringBuilder context)
+        {
+            return x6FTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x70 node, StringBuilder context)
+        {
+            return x70Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x71 node, StringBuilder context)
+        {
+            return x71Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x72 node, StringBuilder context)
+        {
+            return x72Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x73 node, StringBuilder context)
+        {
+            return x73Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x74 node, StringBuilder context)
+        {
+            return x74Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x75 node, StringBuilder context)
+        {
+            return x75Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x76 node, StringBuilder context)
+        {
+            return x76Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x77 node, StringBuilder context)
+        {
+            return x77Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x78 node, StringBuilder context)
+        {
+            return x78Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x79 node, StringBuilder context)
+        {
+            return x79Transcriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x7A node, StringBuilder context)
+        {
+            return x7ATranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x7B node, StringBuilder context)
+        {
+            return x7BTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x7C node, StringBuilder context)
+        {
+            return x7CTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x7D node, StringBuilder context)
+        {
+            return x7DTranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+        protected internal override Void Accept(ProseVal.x7E node, StringBuilder context)
+        {
+            return x7ETranscriber.Instance.Transcribe(node.Value, context);
+        }
+
+    }
+
+}
diff --git a/odata/AbnfParser/Transcribers/RepeatTranscriber.cs b/odata/AbnfParser/Transcribers/RepeatTranscriber.cs
new file mode 100644
index 0000000000..88b82af1f4
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/RepeatTranscriber.cs
@@ -0,0 +1,44 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class RepeatTranscriber : Repeat.Visitor<Void, StringBuilder>
+    {
+        private RepeatTranscriber()
+        {
+        }
+
+        public static RepeatTranscriber Instance { get; } = new RepeatTranscriber();
+
+        protected internal override Void Accept(Repeat.Count node, StringBuilder context)
+        {
+            foreach (var digit in node.Digits)
+            {
+                DigitTranscriber.Instance.Visit(digit, context);
+            }
+
+            return default;
+        }
+
+        protected internal override Void Accept(Repeat.Range node, StringBuilder context)
+        {
+            foreach (var prefixDigit in node.PrefixDigits)
+            {
+                DigitTranscriber.Instance.Visit(prefixDigit, context);
+            }
+
+            x2ATranscriber.Instance.Transcribe(node.Asterisk, context);
+
+            foreach (var suffixDigit in node.SuffixDigits)
+            {
+                DigitTranscriber.Instance.Visit(suffixDigit, context);
+            }
+
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/RepetitionTranscriber.cs b/odata/AbnfParser/Transcribers/RepetitionTranscriber.cs
new file mode 100644
index 0000000000..fe24ddc4fa
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/RepetitionTranscriber.cs
@@ -0,0 +1,29 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using Root;
+
+    public sealed class RepetitionTranscriber : Repetition.Visitor<Void, StringBuilder>
+    {
+        private RepetitionTranscriber()
+        {
+        }
+
+        public static RepetitionTranscriber Instance { get; } = new RepetitionTranscriber();
+
+        protected internal override Void Accept(Repetition.ElementOnly node, StringBuilder context)
+        {
+            ElementTranscriber.Instance.Visit(node.Element, context);
+            return default;
+        }
+
+        protected internal override Void Accept(Repetition.RepeatAndElement node, StringBuilder context)
+        {
+            RepeatTranscriber.Instance.Visit(node.Repeat, context);
+            ElementTranscriber.Instance.Visit(node.Element, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/RuleListTranscriber.cs b/odata/AbnfParser/Transcribers/RuleListTranscriber.cs
new file mode 100644
index 0000000000..e8aee22ccd
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/RuleListTranscriber.cs
@@ -0,0 +1,52 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using Root;
+    
+    public sealed class RuleListTranscriber
+    {
+        private RuleListTranscriber()
+        {
+        }
+
+        public static RuleListTranscriber Instance { get; } = new RuleListTranscriber();
+
+        public Void Transcribe(RuleList node, StringBuilder context)
+        {
+            foreach (var inner in node.Inners)
+            {
+                InnerTranscriber.Instance.Visit(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class InnerTranscriber : RuleList.Inner.Visitor<Void, StringBuilder>
+        {
+            private InnerTranscriber()
+            {
+            }
+
+            public static InnerTranscriber Instance { get; } = new InnerTranscriber();
+
+            protected internal override Void Accept(RuleList.Inner.RuleInner node, StringBuilder context)
+            {
+                RuleTranscriber.Instance.Transcribe(node.Rule, context);
+                return default;
+            }
+
+            protected internal override Void Accept(RuleList.Inner.CommentInner node, StringBuilder context)
+            {
+                foreach (var cwsp in node.Cwsps)
+                {
+                    CwspTranscriber.Instance.Visit(cwsp, context);
+                }
+
+                CnlTranscriber.Instance.Visit(node.Cnl, context);
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/RuleNameTranscriber.cs b/odata/AbnfParser/Transcribers/RuleNameTranscriber.cs
new file mode 100644
index 0000000000..fe521919b3
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/RuleNameTranscriber.cs
@@ -0,0 +1,55 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using AbnfParser.Transcribers.Core;
+    using Root;
+
+    public sealed class RuleNameTranscriber
+    {
+        private RuleNameTranscriber()
+        {
+        }
+
+        public static RuleNameTranscriber Instance { get; } = new RuleNameTranscriber();
+
+        public Void Transcribe(RuleName node, StringBuilder context)
+        {
+            AlphaTranscriber.Instance.Visit(node.Alpha, context);
+            foreach (var inner in node.Inners) //// TODO should you compose transcribers like you do parsers and this would be InnerTranscriber.Instance.Many().Transcribe()? this would also normalize `transcribe` vs `visit`
+            {
+                InnerTranscriber.Instance.Visit(inner, context);
+            }
+
+            return default;
+        }
+
+        public sealed class InnerTranscriber : RuleName.Inner.Visitor<Void, StringBuilder>
+        {
+            private InnerTranscriber()
+            {
+            }
+
+            public static InnerTranscriber Instance { get; } = new InnerTranscriber();
+
+            protected internal override Void Accept(RuleName.Inner.AlphaInner node, StringBuilder context)
+            {
+                AlphaTranscriber.Instance.Visit(node.Alpha, context);
+                return default;
+            }
+
+            protected internal override Void Accept(RuleName.Inner.DigitInner node, StringBuilder context)
+            {
+                DigitTranscriber.Instance.Visit(node.Digit, context);
+                return default;
+            }
+
+            protected internal override Void Accept(RuleName.Inner.DashInner node, StringBuilder context)
+            {
+                x2DTranscriber.Instance.Transcribe(node.Dash, context);
+                return default;
+            }
+        }
+    }
+}
diff --git a/odata/AbnfParser/Transcribers/RuleTranscriber.cs b/odata/AbnfParser/Transcribers/RuleTranscriber.cs
new file mode 100644
index 0000000000..e1a7ec52ec
--- /dev/null
+++ b/odata/AbnfParser/Transcribers/RuleTranscriber.cs
@@ -0,0 +1,25 @@
+namespace AbnfParser.Transcribers
+{
+    using System.Text;
+
+    using AbnfParser.CstNodes;
+    using Root;
+
+    public sealed class RuleTranscriber
+    {
+        private RuleTranscriber()
+        {
+        }
+
+        public static RuleTranscriber Instance { get; } = new RuleTranscriber();
+
+        public Void Transcribe(Rule node, StringBuilder context)
+        {
+            RuleNameTranscriber.Instance.Transcribe(node.RuleName, context);
+            DefinedAsTranscriber.Instance.Visit(node.DefinedAs, context);
+            ElementsTranscriber.Instance.Transcribe(node.Elements, context);
+            CnlTranscriber.Instance.Visit(node.Cnl, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/AbnfParser/abnf.abnf b/odata/AbnfParser/abnf.abnf
new file mode 100644
index 0000000000..a07deb1810
--- /dev/null
+++ b/odata/AbnfParser/abnf.abnf
@@ -0,0 +1,59 @@
+rulelist       =  1*( rule / (*c-wsp c-nl) )
+
+rule           =  rulename defined-as elements c-nl
+                    ; continues if next line starts
+                    ;  with white space
+
+rulename       =  ALPHA *(ALPHA / DIGIT / "-")
+
+defined-as     =  *c-wsp ("=" / "=/") *c-wsp
+                    ; basic rules definition and
+                    ;  incremental alternatives
+
+elements       =  alternation *c-wsp
+
+c-wsp          =  WSP / (c-nl WSP)
+
+c-nl           =  comment / CRLF
+                    ; comment or newline
+
+comment        =  ";" *(WSP / VCHAR) CRLF
+
+alternation    =  concatenation
+                *(*c-wsp "/" *c-wsp concatenation)
+
+concatenation  =  repetition *(1*c-wsp repetition)
+
+repetition     =  [repeat] element
+
+repeat         =  1*DIGIT / (*DIGIT "*" *DIGIT)
+
+element        =  rulename / group / option /
+                char-val / num-val / prose-val
+
+group          =  "(" *c-wsp alternation *c-wsp ")"
+
+option         =  "[" *c-wsp alternation *c-wsp "]"
+
+char-val       =  DQUOTE *(%x20-21 / %x23-7E) DQUOTE
+                    ; quoted string of SP and VCHAR
+                    ;  without DQUOTE
+
+num-val        =  "%" (bin-val / dec-val / hex-val)
+
+bin-val        =  "b" 1*BIT
+                [ 1*("." 1*BIT) / ("-" 1*BIT) ]
+                    ; series of concatenated bit values
+                    ;  or single ONEOF range
+
+dec-val        =  "d" 1*DIGIT
+                [ 1*("." 1*DIGIT) / ("-" 1*DIGIT) ]
+
+hex-val        =  "x" 1*HEXDIG
+                [ 1*("." 1*HEXDIG) / ("-" 1*HEXDIG) ]
+
+prose-val      =  "<" *(%x20-3D / %x3F-7E) ">"
+                    ; bracketed string of SP and VCHAR
+                    ;  without angles
+                    ; prose description, to be used as
+                    ;  last resort
diff --git a/odata/AbnfParser/core.abnf b/odata/AbnfParser/core.abnf
new file mode 100644
index 0000000000..691aea8919
--- /dev/null
+++ b/odata/AbnfParser/core.abnf
@@ -0,0 +1,52 @@
+ALPHA          =  %x41-5A / %x61-7A   ; A-Z / a-z
+
+BIT            =  "0" / "1"
+
+CHAR           =  %x01-7F
+                    ; any 7-bit US-ASCII character,
+                    ;  excluding NUL
+
+CR             =  %x0D
+                    ; carriage return
+
+CRLF           =  CR LF
+                    ; Internet standard newline
+
+CTL            =  %x00-1F / %x7F
+                    ; controls
+
+DIGIT          =  %x30-39
+                    ; 0-9
+
+DQUOTE         =  %x22
+                    ; " (Double Quote)
+
+HEXDIG         =  DIGIT / "A" / "B" / "C" / "D" / "E" / "F"
+
+HTAB           =  %x09
+                    ; horizontal tab
+
+LF             =  %x0A
+                    ; linefeed
+
+LWSP           =  *(WSP / CRLF WSP)
+                    ; Use of this linear-white-space rule
+                    ;  permits lines containing only white
+                    ;  space that are no longer legal in
+                    ;  mail headers and have caused
+                    ;  interoperability problems in other
+                    ;  contexts.
+                    ; Do not use when defining mail
+                    ;  headers and use with caution in
+                    ;  other contexts.
+
+OCTET          =  %x00-FF
+                    ; 8 bits of data
+
+SP             =  %x20
+
+VCHAR          =  %x21-7E
+                    ; visible (printing) characters
+
+WSP            =  SP / HTAB
+                    ; white space
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/BatchOptions.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/BatchOptions.cs
new file mode 100644
index 0000000000..d0cdd1ecdf
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/BatchOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class BatchOptions
+    {
+        private BatchOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(BatchOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/Context.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/Context.cs
new file mode 100644
index 0000000000..a740f43679
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/Context.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class Context
+    {
+        private Context()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Context node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/EntityCastOptions.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/EntityCastOptions.cs
new file mode 100644
index 0000000000..c145f5e9b2
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/EntityCastOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class EntityCastOptions
+    {
+        private EntityCastOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(EntityCastOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/EntityOptions.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/EntityOptions.cs
new file mode 100644
index 0000000000..b6acb2e319
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/EntityOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class EntityOptions
+    {
+        private EntityOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(EntityOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/MetadataOptions.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/MetadataOptions.cs
new file mode 100644
index 0000000000..842dc5c20d
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/MetadataOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class MetadataOptions
+    {
+        private MetadataOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(MetadataOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/OdataRelativeUri.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/OdataRelativeUri.cs
new file mode 100644
index 0000000000..a3f76ad2eb
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/OdataRelativeUri.cs
@@ -0,0 +1,188 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    /// <summary>
+    /// this is the AST for odata resource paths
+    /// pulled from `odataRelativeUri` definition in https://docs.oasis-open.org/odata/odata/v4.01/cs01/abnf/odata-abnf-construction-rules.txt
+    /// </summary>
+    public abstract class OdataRelativeUri
+    {
+        private OdataRelativeUri()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(OdataRelativeUri node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            public abstract TResult Accept(BatchOnly node, TContext context);
+            public abstract TResult Accept(BatchWithOptions node, TContext context);
+            public abstract TResult Accept(EntityWithOptions node, TContext context);
+            public abstract TResult Accept(EntityWithCast node, TContext context);
+            public abstract TResult Accept(MetadataOnly node, TContext context);
+            public abstract TResult Accept(MetadataWithOptions node, TContext context);
+            public abstract TResult Accept(MetadataWithContext node, TContext context);
+            public abstract TResult Accept(MetadataWithOptionsAndContext node, TContext context);
+            public abstract TResult Accept(ResourcePathOnly node, TContext context);
+            public abstract TResult Accept(ResourcePathWithQueryOptions node, TContext context);
+        }
+
+        public sealed class BatchOnly : OdataRelativeUri
+        {
+            private BatchOnly()
+            {
+            }
+
+            public static BatchOnly Instance { get; } = new BatchOnly();
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class BatchWithOptions : OdataRelativeUri
+        {
+            public BatchWithOptions(BatchOptions batchOptions)
+            {
+                this.BatchOptions = batchOptions;
+            }
+
+            public BatchOptions BatchOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class EntityWithOptions : OdataRelativeUri
+        {
+            public EntityWithOptions(EntityOptions entityOptions)
+            {
+                this.EntityOptions = entityOptions;
+            }
+
+            public EntityOptions EntityOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class EntityWithCast : OdataRelativeUri
+        {
+            public EntityWithCast(QualifiedEntityTypeName qualifiedEntityTypeName, EntityCastOptions entityCastOptions)
+            {
+                this.QualifiedEntityTypeName = qualifiedEntityTypeName;
+                this.EntityCastOptions = entityCastOptions;
+            }
+
+            public QualifiedEntityTypeName QualifiedEntityTypeName { get; }
+            public EntityCastOptions EntityCastOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataOnly : OdataRelativeUri
+        {
+            private MetadataOnly()
+            {
+            }
+
+            public static MetadataOnly Instance { get; } = new MetadataOnly();
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataWithOptions : OdataRelativeUri
+        {
+            public MetadataWithOptions(MetadataOptions metadataOptions)
+            {
+                this.MetadataOptions = metadataOptions;
+            }
+
+            public MetadataOptions MetadataOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataWithContext : OdataRelativeUri
+        {
+            public MetadataWithContext(Context context)
+            {
+                this.Context = context;
+            }
+
+            public Context Context { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataWithOptionsAndContext : OdataRelativeUri
+        {
+            public MetadataWithOptionsAndContext(MetadataOptions metadataOptions, Context context)
+            {
+                this.MetadataOptions = metadataOptions;
+                this.Context = context;
+            }
+
+            public MetadataOptions MetadataOptions { get; }
+            public Context Context { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ResourcePathOnly : OdataRelativeUri
+        {
+            public ResourcePathOnly(ResourcePath resourcePath)
+            {
+                this.ResourcePath = resourcePath;
+            }
+
+            public ResourcePath ResourcePath { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ResourcePathWithQueryOptions : OdataRelativeUri
+        {
+            public ResourcePathWithQueryOptions(ResourcePath resourcePath, QueryOptions queryOptions)
+            {
+                this.ResourcePath = resourcePath;
+                this.QueryOptions = queryOptions;
+            }
+
+            public ResourcePath ResourcePath { get; }
+            public QueryOptions QueryOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/QualifiedEntityTypeName.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/QualifiedEntityTypeName.cs
new file mode 100644
index 0000000000..a51434c1d6
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/QualifiedEntityTypeName.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class QualifiedEntityTypeName
+    {
+        private QualifiedEntityTypeName()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(QualifiedEntityTypeName node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/QueryOptions.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/QueryOptions.cs
new file mode 100644
index 0000000000..8839ad698e
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/QueryOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class QueryOptions
+    {
+        private QueryOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(QueryOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/ResourcePath.cs b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/ResourcePath.cs
new file mode 100644
index 0000000000..61d342016a
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AbstractSyntaxTreeNodes/ResourcePath.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.AbstractSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class ResourcePath
+    {
+        private ResourcePath()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(ResourcePath node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/BatchOptionsConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/BatchOptionsConverter.cs
new file mode 100644
index 0000000000..ba38f924f1
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/BatchOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class BatchOptionsConverter : 
+        AbstractSyntaxTreeNodes.BatchOptions.Visitor<
+            ConcreteSyntaxTreeNodes.BatchOptions, 
+            Void>
+    {
+        private BatchOptionsConverter()
+        {
+        }
+
+        public static BatchOptionsConverter Default { get; } = new BatchOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/ContextConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/ContextConverter.cs
new file mode 100644
index 0000000000..52c19eb4ec
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/ContextConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+    
+    public sealed class ContextConverter :
+        AbstractSyntaxTreeNodes.Context.Visitor<
+            ConcreteSyntaxTreeNodes.Context,
+            Void>
+    {
+        private ContextConverter()
+        {
+        }
+
+        public static ContextConverter Default { get; } = new ContextConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/EntityCastOptionsConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/EntityCastOptionsConverter.cs
new file mode 100644
index 0000000000..0912b9f51f
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/EntityCastOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class EntityCastOptionsConverter :
+        AbstractSyntaxTreeNodes.EntityCastOptions.Visitor<
+            ConcreteSyntaxTreeNodes.EntityCastOptions,
+            Void>
+    {
+        private EntityCastOptionsConverter()
+        {
+        }
+
+        public static EntityCastOptionsConverter Default { get; } = new EntityCastOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/EntityOptionsConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/EntityOptionsConverter.cs
new file mode 100644
index 0000000000..8f736b2ed9
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/EntityOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class EntityOptionsConverter :
+        AbstractSyntaxTreeNodes.EntityOptions.Visitor<
+            ConcreteSyntaxTreeNodes.EntityOptions,
+            Void>
+    {
+        private EntityOptionsConverter()
+        {
+        }
+
+        public static EntityOptionsConverter Default { get; } = new EntityOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/MetadataOptionsConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/MetadataOptionsConverter.cs
new file mode 100644
index 0000000000..f91163103c
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/MetadataOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class MetadataOptionsConverter :
+        AbstractSyntaxTreeNodes.MetadataOptions.Visitor<
+            ConcreteSyntaxTreeNodes.MetadataOptions,
+            Void>
+    {
+        private MetadataOptionsConverter()
+        {
+        }
+
+        public static MetadataOptionsConverter Default { get; } = new MetadataOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/OdataRelativeUriConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/OdataRelativeUriConverter.cs
new file mode 100644
index 0000000000..62b6dbf292
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/OdataRelativeUriConverter.cs
@@ -0,0 +1,130 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class OdataRelativeUriConverter :
+        AbstractSyntaxTreeNodes.OdataRelativeUri.Visitor<
+            ConcreteSyntaxTreeNodes.OdataRelativeUri,
+            Void>
+    {
+        private readonly BatchOptionsConverter batchOptionsCstToAstTranslator;
+        private readonly EntityOptionsConverter entityOptionsTranslator;
+        private readonly QualifiedEntityTypeNameConverter qualifiedEntityTypeNameTranslator;
+        private readonly EntityCastOptionsConverter entityCastOptionsTranslator;
+        private readonly MetadataOptionsConverter metadataOptionsTranslator;
+        private readonly ContextConverter contextTranslator;
+        private readonly ResourcePathConverter resourcePathTranslator;
+        private readonly QueryOptionsConverter queryOptionsTranslator;
+
+        private OdataRelativeUriConverter(
+            BatchOptionsConverter batchOptionsCstToAstTranslator,
+            EntityOptionsConverter entityOptionsTranslator,
+            QualifiedEntityTypeNameConverter qualifiedEntityTypeNameTranslator,
+            EntityCastOptionsConverter entityCastOptionsTranslator,
+            MetadataOptionsConverter metadataOptionsTranslator,
+            ContextConverter contextTranslator,
+            ResourcePathConverter resourcePathTranslator,
+            QueryOptionsConverter queryOptionsTranslator)
+        {
+            this.batchOptionsCstToAstTranslator = batchOptionsCstToAstTranslator;
+            this.entityOptionsTranslator = entityOptionsTranslator;
+            this.qualifiedEntityTypeNameTranslator = qualifiedEntityTypeNameTranslator;
+            this.entityCastOptionsTranslator = entityCastOptionsTranslator;
+            this.metadataOptionsTranslator = metadataOptionsTranslator;
+            this.contextTranslator = contextTranslator;
+            this.resourcePathTranslator = resourcePathTranslator;
+            this.queryOptionsTranslator = queryOptionsTranslator;
+        }
+
+        public static OdataRelativeUriConverter Default { get; } = new OdataRelativeUriConverter(
+            BatchOptionsConverter.Default,
+            EntityOptionsConverter.Default,
+            QualifiedEntityTypeNameConverter.Default,
+            EntityCastOptionsConverter.Default,
+            MetadataOptionsConverter.Default,
+            ContextConverter.Default,
+            ResourcePathConverter.Default,
+            QueryOptionsConverter.Default);
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.BatchOnly node,
+            Void context)
+        {
+            return ConcreteSyntaxTreeNodes.OdataRelativeUri.BatchOnly.Instance;
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.BatchWithOptions node,
+            Void context)
+        {
+            var batchOptions = this.batchOptionsCstToAstTranslator.Visit(node.BatchOptions, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.BatchWithOptions(batchOptions);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.EntityWithOptions node,
+            Void context)
+        {
+            var entityOptions = this.entityOptionsTranslator.Visit(node.EntityOptions, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.EntityWithOptions(entityOptions);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.EntityWithCast node,
+            Void context)
+        {
+            var qualifiedEntityTypeName = this.qualifiedEntityTypeNameTranslator.Visit(node.QualifiedEntityTypeName, context);
+            var entityCastOptions = this.entityCastOptionsTranslator.Visit(node.EntityCastOptions, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.EntityWithCast(qualifiedEntityTypeName, entityCastOptions);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataOnly node,
+            Void context)
+        {
+            return ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataOnly.Instance;
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptions node,
+            Void context)
+        {
+            var metadataOptions = this.metadataOptionsTranslator.Visit(node.MetadataOptions, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptions(metadataOptions);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataWithContext node,
+            Void context)
+        {
+            var metadataContext = this.contextTranslator.Visit(node.Context, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataWithContext(metadataContext);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptionsAndContext node,
+            Void context)
+        {
+            var metadataOptions = this.metadataOptionsTranslator.Visit(node.MetadataOptions, context);
+            var metadataContext = this.contextTranslator.Visit(node.Context, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptionsAndContext(metadataOptions, metadataContext);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.ResourcePathOnly node,
+            Void context)
+        {
+            var resourcePath = this.resourcePathTranslator.Visit(node.ResourcePath, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.ResourcePathOnly(resourcePath);
+        }
+
+        public override ConcreteSyntaxTreeNodes.OdataRelativeUri Accept(
+            AbstractSyntaxTreeNodes.OdataRelativeUri.ResourcePathWithQueryOptions node,
+            Void context)
+        {
+            var resourcePath = this.resourcePathTranslator.Visit(node.ResourcePath, context);
+            var queryOptions = this.queryOptionsTranslator.Visit(node.QueryOptions, context);
+            return new ConcreteSyntaxTreeNodes.OdataRelativeUri.ResourcePathWithQueryOptions(resourcePath, queryOptions);
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/QualifiedEntityTypeNameConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/QualifiedEntityTypeNameConverter.cs
new file mode 100644
index 0000000000..0e98234d8f
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/QualifiedEntityTypeNameConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class QualifiedEntityTypeNameConverter :
+        AbstractSyntaxTreeNodes.QualifiedEntityTypeName.Visitor<
+            ConcreteSyntaxTreeNodes.QualifiedEntityTypeName,
+            Void>
+    {
+        private QualifiedEntityTypeNameConverter()
+        {
+        }
+
+        public static QualifiedEntityTypeNameConverter Default { get; } = new QualifiedEntityTypeNameConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/QueryOptionsConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/QueryOptionsConverter.cs
new file mode 100644
index 0000000000..4d2f3c02bf
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/QueryOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class QueryOptionsConverter :
+        AbstractSyntaxTreeNodes.QueryOptions.Visitor<
+            ConcreteSyntaxTreeNodes.QueryOptions,
+            Void>
+    {
+        private QueryOptionsConverter()
+        {
+        }
+
+        public static QueryOptionsConverter Default { get; } = new QueryOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/AstToCstConverters/ResourcePathConverter.cs b/odata/Root/OdataResourcePath/AstToCstConverters/ResourcePathConverter.cs
new file mode 100644
index 0000000000..99d4dfbced
--- /dev/null
+++ b/odata/Root/OdataResourcePath/AstToCstConverters/ResourcePathConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.AstToCstConverters
+{
+    using Root;
+
+    public sealed class ResourcePathConverter :
+        AbstractSyntaxTreeNodes.ResourcePath.Visitor<
+            ConcreteSyntaxTreeNodes.ResourcePath,
+            Void>
+    {
+        private ResourcePathConverter()
+        {
+        }
+
+        public static ResourcePathConverter Default { get; } = new ResourcePathConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/BatchOptionsParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/BatchOptionsParser.cs
new file mode 100644
index 0000000000..9e9cda0d64
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/BatchOptionsParser.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class BatchOptionsParser
+    {
+        public static Parser<BatchOptions> Instance { get; } = Parser.None<BatchOptions>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/BatchParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/BatchParser.cs
new file mode 100644
index 0000000000..6c3cc5a56f
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/BatchParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class BatchParser
+    {
+        public static Parser<Batch> Instance { get; } = Parse
+            .String("$batch")
+            .Return(Batch.Instance);
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/ContextParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/ContextParser.cs
new file mode 100644
index 0000000000..1a99dea959
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/ContextParser.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class ContextParser
+    {
+        public static Parser<Context> Instance { get; } = Parser.None<Context>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/EntityCastOptionsParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/EntityCastOptionsParser.cs
new file mode 100644
index 0000000000..9ff2fae563
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/EntityCastOptionsParser.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class EntityCastOptionsParser
+    {
+        public static Parser<EntityCastOptions> Instance { get; } = Parser.None<EntityCastOptions>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/EntityOptionsParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/EntityOptionsParser.cs
new file mode 100644
index 0000000000..6f35c0ffae
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/EntityOptionsParser.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class EntityOptionsParser
+    {
+        public static Parser<EntityOptions> Instance { get; } = Parser.None<EntityOptions>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/EntityParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/EntityParser.cs
new file mode 100644
index 0000000000..32352e9e16
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/EntityParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class EntityParser
+    {
+        public static Parser<Entity> Instance { get; } = Parse
+            .String("$entity")
+            .Return(Entity.Instance);
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/MetadataOptionsParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/MetadataOptionsParser.cs
new file mode 100644
index 0000000000..d541f54dd7
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/MetadataOptionsParser.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class MetadataOptionsParser
+    {
+        public static Parser<MetadataOptions> Instance { get; } = Parser.None<MetadataOptions>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/MetadataParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/MetadataParser.cs
new file mode 100644
index 0000000000..7b8dba68b2
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/MetadataParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class MetadataParser
+    {
+        public static Parser<Metadata> Instance { get; } = Parse
+            .String("$metadata")
+            .Return(Metadata.Instance);
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/OdataRelativeUriParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/OdataRelativeUriParser.cs
new file mode 100644
index 0000000000..cd381fc072
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/OdataRelativeUriParser.cs
@@ -0,0 +1,77 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class OdataRelativeUriParser
+    {
+        public static Parser<OdataRelativeUri.BatchOnly> BatchOnly { get; } =
+            from batch in BatchParser.Instance
+            select OdataRelativeUri.BatchOnly.Instance;
+
+        public static Parser<OdataRelativeUri.BatchWithOptions> BatchWithOptions { get; } =
+            //// TODO can you avoid using this syntax?
+            from batch in BatchParser.Instance
+            from questionMark in QuestionMarkParser.Instance
+            from batchOptions in BatchOptionsParser.Instance
+            select new OdataRelativeUri.BatchWithOptions(batchOptions);
+
+        public static Parser<OdataRelativeUri.EntityWithOptions> EntityWithOptions { get; } =
+            from entity in EntityParser.Instance
+            from questionMark in QuestionMarkParser.Instance
+            from entityOptions in EntityOptionsParser.Instance
+            select new OdataRelativeUri.EntityWithOptions(entityOptions);
+
+        public static Parser<OdataRelativeUri.EntityWithCast> EntityWithCast { get; } =
+            from entity in EntityParser.Instance
+            from slash in SlashParser.Instance
+            from qualifiedTypeName in QualifiedTypeNameParser.Instance
+            from questionMark in QuestionMarkParser.Instance
+            from entityCastOptions in EntityCastOptionsParser.Instance
+            select new OdataRelativeUri.EntityWithCast(qualifiedTypeName, entityCastOptions);
+
+        public static Parser<OdataRelativeUri.MetadataOnly> MetadataOnly { get; } =
+            from metadata in MetadataParser.Instance
+            select OdataRelativeUri.MetadataOnly.Instance;
+
+        public static Parser<OdataRelativeUri.MetadataWithOptions> MetadataWithOptions { get; } =
+            from metadata in MetadataParser.Instance
+            from questionMark in QuestionMarkParser.Instance
+            from metadataOptions in MetadataOptionsParser.Instance
+            select new OdataRelativeUri.MetadataWithOptions(metadataOptions);
+
+        public static Parser<OdataRelativeUri.MetadataWithContext> MetadataWithContext { get; } =
+            from metadata in MetadataParser.Instance
+            from context in ContextParser.Instance
+            select new OdataRelativeUri.MetadataWithContext(context);
+
+        public static Parser<OdataRelativeUri.MetadataWithOptionsAndContext> MetadataWithOptionsAndContext { get; } =
+            from metadata in MetadataParser.Instance
+            from questionMark in QuestionMarkParser.Instance
+            from metadataOptions in MetadataOptionsParser.Instance
+            from context in ContextParser.Instance
+            select new OdataRelativeUri.MetadataWithOptionsAndContext(metadataOptions, context);
+
+        public static Parser<OdataRelativeUri.ResourcePathOnly> ResourcePathOnly { get; } =
+            from resourcePath in ResourcePathParser.Instance
+            select new OdataRelativeUri.ResourcePathOnly(resourcePath);
+
+        public static Parser<OdataRelativeUri.ResourcePathWithQueryOptions> ResourcePathWithQueryOptions { get; } =
+            from resourcePath in ResourcePathParser.Instance
+            from questionMark in QuestionMarkParser.Instance
+            from queryOptions in QueryOptionsParser.Instance
+            select new OdataRelativeUri.ResourcePathWithQueryOptions(resourcePath, queryOptions);
+
+        public static Parser<OdataRelativeUri> Instance { get; } =
+            BatchOnly
+            .Or<OdataRelativeUri>(BatchWithOptions)
+            .Or(EntityWithOptions)
+            .Or(EntityWithCast)
+            .Or(MetadataOnly)
+            .Or(MetadataWithOptions)
+            .Or(MetadataWithContext)
+            .Or(MetadataWithOptionsAndContext)
+            .Or(ResourcePathOnly)
+            .Or(ResourcePathWithQueryOptions);
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/QualifiedTypeNameParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/QualifiedTypeNameParser.cs
new file mode 100644
index 0000000000..5335c92dad
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/QualifiedTypeNameParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class QualifiedTypeNameParser
+    {
+        //// TODO how to implement this for the "Feature gap" case?
+        public static Parser<QualifiedEntityTypeName> Instance { get; } = Parser.None<QualifiedEntityTypeName>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/QueryOptionsParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/QueryOptionsParser.cs
new file mode 100644
index 0000000000..c064675c77
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/QueryOptionsParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class QueryOptionsParser
+    {
+        //// TODO how to implement this for the "Feature gap" case?
+        public static Parser<QueryOptions> Instance { get; } = Parser.None<QueryOptions>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/QuestionMarkParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/QuestionMarkParser.cs
new file mode 100644
index 0000000000..f951e2c1b2
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/QuestionMarkParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class QuestionMarkParser
+    {
+        public static Parser<QuestionMark> Instance { get; } = Parse
+            .String("?")
+            .Return(QuestionMark.Instance);
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/ResourcePathParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/ResourcePathParser.cs
new file mode 100644
index 0000000000..eb3da00d10
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/ResourcePathParser.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class ResourcePathParser
+    {
+        public static Parser<ResourcePath> Instance { get; } = Parser.None<ResourcePath>(
+            "BatchOptions parsing has not been implemented");
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CombinatorParsers/SlashParser.cs b/odata/Root/OdataResourcePath/CombinatorParsers/SlashParser.cs
new file mode 100644
index 0000000000..ef17cff7bf
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CombinatorParsers/SlashParser.cs
@@ -0,0 +1,12 @@
+namespace Root.OdataResourcePath.CombinatorParsers
+{
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+    using Sprache;
+
+    public static class SlashParser
+    {
+        public static Parser<Slash> Instance { get; } = Parse
+            .String("/")
+            .Return(Slash.Instance);
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Batch.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Batch.cs
new file mode 100644
index 0000000000..344213fd6f
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Batch.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    public sealed class Batch
+    {
+        private Batch()
+        {
+        }
+
+        public static Batch Instance { get; } = new Batch();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/BatchOptions.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/BatchOptions.cs
new file mode 100644
index 0000000000..3b95211d84
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/BatchOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class BatchOptions
+    {
+        private BatchOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(BatchOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Context.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Context.cs
new file mode 100644
index 0000000000..ebbfd10c2b
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Context.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class Context
+    {
+        private Context()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(Context node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Entity.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Entity.cs
new file mode 100644
index 0000000000..83d1582bcd
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Entity.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    public sealed class Entity
+    {
+        private Entity()
+        {
+        }
+
+        public static Entity Instance { get; } = new Entity();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/EntityCastOptions.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/EntityCastOptions.cs
new file mode 100644
index 0000000000..664dfcc184
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/EntityCastOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class EntityCastOptions
+    {
+        private EntityCastOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(EntityCastOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/EntityOptions.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/EntityOptions.cs
new file mode 100644
index 0000000000..35c797bafc
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/EntityOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class EntityOptions
+    {
+        private EntityOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(EntityOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Metadata.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Metadata.cs
new file mode 100644
index 0000000000..6322036e76
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Metadata.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    public sealed class Metadata
+    {
+        private Metadata()
+        {
+        }
+
+        public static Metadata Instance { get; } = new Metadata();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/MetadataOptions.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/MetadataOptions.cs
new file mode 100644
index 0000000000..89e89fa1da
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/MetadataOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class MetadataOptions
+    {
+        private MetadataOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(MetadataOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/OdataRelativeUri.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/OdataRelativeUri.cs
new file mode 100644
index 0000000000..8a5a000f1c
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/OdataRelativeUri.cs
@@ -0,0 +1,222 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    /// <summary>
+    /// this is the AST for odata resource paths
+    /// pulled from `odataRelativeUri` definition in https://docs.oasis-open.org/odata/odata/v4.01/cs01/abnf/odata-abnf-construction-rules.txt
+    /// </summary>
+    public abstract class OdataRelativeUri
+    {
+        private OdataRelativeUri()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(OdataRelativeUri node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+
+            public abstract TResult Accept(BatchOnly node, TContext context);
+            public abstract TResult Accept(BatchWithOptions node, TContext context);
+            public abstract TResult Accept(EntityWithOptions node, TContext context);
+            public abstract TResult Accept(EntityWithCast node, TContext context);
+            public abstract TResult Accept(MetadataOnly node, TContext context);
+            public abstract TResult Accept(MetadataWithOptions node, TContext context);
+            public abstract TResult Accept(MetadataWithContext node, TContext context);
+            public abstract TResult Accept(MetadataWithOptionsAndContext node, TContext context);
+            public abstract TResult Accept(ResourcePathOnly node, TContext context);
+            public abstract TResult Accept(ResourcePathWithQueryOptions node, TContext context);
+        }
+
+        public sealed class BatchOnly : OdataRelativeUri
+        {
+            private BatchOnly()
+            {
+                this.Batch = Batch.Instance;
+                this.QuestionMark = QuestionMark.Instance;
+            }
+
+            public Batch Batch { get; }
+            public QuestionMark QuestionMark { get; }
+
+            public static BatchOnly Instance { get; } = new BatchOnly();
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class BatchWithOptions : OdataRelativeUri
+        {
+            public BatchWithOptions(BatchOptions batchOptions)
+            {
+                this.Batch = Batch.Instance;
+                this.QuestionMark = QuestionMark.Instance;
+                this.BatchOptions = batchOptions;
+            }
+
+            public Batch Batch { get; }
+            public QuestionMark QuestionMark { get; }
+            public BatchOptions BatchOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class EntityWithOptions : OdataRelativeUri
+        {
+            public EntityWithOptions(EntityOptions entityOptions)
+            {
+                this.Entity = Entity.Instance;
+                this.QuestionMark = QuestionMark.Instance;
+                this.EntityOptions = entityOptions;
+            }
+
+            public Entity Entity { get; }
+            public QuestionMark QuestionMark { get; }
+            public EntityOptions EntityOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class EntityWithCast : OdataRelativeUri
+        {
+            public EntityWithCast(QualifiedEntityTypeName qualifiedEntityTypeName, EntityCastOptions entityCastOptions)
+            {
+                this.Entity = Entity.Instance;
+                this.Slash = Slash.Instance;
+                this.QualifiedEntityTypeName = qualifiedEntityTypeName;
+                this.QuestionMark = QuestionMark.Instance;
+                this.EntityCastOptions = entityCastOptions;
+            }
+
+            public Entity Entity { get; }
+            public Slash Slash { get; }
+            public QualifiedEntityTypeName QualifiedEntityTypeName { get; }
+            public QuestionMark QuestionMark { get; }
+            public EntityCastOptions EntityCastOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataOnly : OdataRelativeUri
+        {
+            private MetadataOnly()
+            {
+                this.Metadata = Metadata.Instance;
+            }
+
+            public Metadata Metadata { get; }
+
+            public static MetadataOnly Instance { get; } = new MetadataOnly();
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataWithOptions : OdataRelativeUri
+        {
+            public MetadataWithOptions(MetadataOptions metadataOptions)
+            {
+                this.Metadata = Metadata.Instance;
+                this.QuestionMark = QuestionMark.Instance;
+                this.MetadataOptions = metadataOptions;
+            }
+
+            public Metadata Metadata { get; }
+            public QuestionMark QuestionMark { get; }
+            public MetadataOptions MetadataOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataWithContext : OdataRelativeUri
+        {
+            public MetadataWithContext(Context context)
+            {
+                this.Metadata = Metadata.Instance;
+                this.Context = context;
+            }
+
+            public Metadata Metadata { get; }
+            public Context Context { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class MetadataWithOptionsAndContext : OdataRelativeUri
+        {
+            public MetadataWithOptionsAndContext(MetadataOptions metadataOptions, Context context)
+            {
+                this.Metadata = Metadata.Instance;
+                this.QuestionMark = QuestionMark.Instance;
+                this.MetadataOptions = metadataOptions;
+                this.Context = context;
+            }
+
+            public Metadata Metadata { get; }
+            public QuestionMark QuestionMark { get; }
+            public MetadataOptions MetadataOptions { get; }
+            public Context Context { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ResourcePathOnly : OdataRelativeUri
+        {
+            public ResourcePathOnly(ResourcePath resourcePath)
+            {
+                this.ResourcePath = resourcePath;
+            }
+
+            public ResourcePath ResourcePath { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+
+        public sealed class ResourcePathWithQueryOptions : OdataRelativeUri
+        {
+            public ResourcePathWithQueryOptions(ResourcePath resourcePath, QueryOptions queryOptions)
+            {
+                this.ResourcePath = resourcePath;
+                this.QuestionMark = QuestionMark.Instance;
+                this.QueryOptions = queryOptions;
+            }
+
+            public ResourcePath ResourcePath { get; }
+            public QuestionMark QuestionMark { get; }
+            public QueryOptions QueryOptions { get; }
+
+            protected sealed override TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context)
+            {
+                return visitor.Accept(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QualifiedEntityTypeName.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QualifiedEntityTypeName.cs
new file mode 100644
index 0000000000..e40ccdedce
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QualifiedEntityTypeName.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class QualifiedEntityTypeName
+    {
+        private QualifiedEntityTypeName()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(QualifiedEntityTypeName node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QueryOptions.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QueryOptions.cs
new file mode 100644
index 0000000000..12b20a69a7
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QueryOptions.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class QueryOptions
+    {
+        private QueryOptions()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(QueryOptions node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QuestionMark.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QuestionMark.cs
new file mode 100644
index 0000000000..f655fe33b9
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/QuestionMark.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    public sealed class QuestionMark
+    {
+        private QuestionMark()
+        {
+        }
+
+        public static QuestionMark Instance { get; } = new QuestionMark();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/ResourcePath.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/ResourcePath.cs
new file mode 100644
index 0000000000..5db1a44713
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/ResourcePath.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    // TODO this is just a stub for now
+    public abstract class ResourcePath
+    {
+        private ResourcePath()
+        {
+        }
+
+        protected abstract TResult Dispatch<TResult, TContext>(Visitor<TResult, TContext> visitor, TContext context);
+
+        public abstract class Visitor<TResult, TContext>
+        {
+            public TResult Visit(ResourcePath node, TContext context)
+            {
+                return node.Dispatch(this, context);
+            }
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Slash.cs b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Slash.cs
new file mode 100644
index 0000000000..4e1b1a302e
--- /dev/null
+++ b/odata/Root/OdataResourcePath/ConcreteSyntaxTreeNodes/Slash.cs
@@ -0,0 +1,11 @@
+namespace Root.OdataResourcePath.ConcreteSyntaxTreeNodes
+{
+    public sealed class Slash
+    {
+        private Slash()
+        {
+        }
+
+        public static Slash Instance { get; } = new Slash();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/BatchOptionsConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/BatchOptionsConverter.cs
new file mode 100644
index 0000000000..44fc218b51
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/BatchOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class BatchOptionsConverter : 
+        ConcreteSyntaxTreeNodes.BatchOptions.Visitor<
+            AbstractSyntaxTreeNodes.BatchOptions, 
+            Void>
+    {
+        private BatchOptionsConverter()
+        {
+        }
+
+        public static BatchOptionsConverter Default { get; } = new BatchOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/ContextConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/ContextConverter.cs
new file mode 100644
index 0000000000..33ba1bc519
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/ContextConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+    
+    public sealed class ContextConverter :
+        ConcreteSyntaxTreeNodes.Context.Visitor<
+            AbstractSyntaxTreeNodes.Context,
+            Void>
+    {
+        private ContextConverter()
+        {
+        }
+
+        public static ContextConverter Default { get; } = new ContextConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/EntityCastOptionsConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/EntityCastOptionsConverter.cs
new file mode 100644
index 0000000000..89677b8a0b
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/EntityCastOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class EntityCastOptionsConverter :
+        ConcreteSyntaxTreeNodes.EntityCastOptions.Visitor<
+            AbstractSyntaxTreeNodes.EntityCastOptions,
+            Void>
+    {
+        private EntityCastOptionsConverter()
+        {
+        }
+
+        public static EntityCastOptionsConverter Default { get; } = new EntityCastOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/EntityOptionsConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/EntityOptionsConverter.cs
new file mode 100644
index 0000000000..c02722df1c
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/EntityOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class EntityOptionsConverter :
+        ConcreteSyntaxTreeNodes.EntityOptions.Visitor<
+            AbstractSyntaxTreeNodes.EntityOptions,
+            Void>
+    {
+        private EntityOptionsConverter()
+        {
+        }
+
+        public static EntityOptionsConverter Default { get; } = new EntityOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/MetadataOptionsConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/MetadataOptionsConverter.cs
new file mode 100644
index 0000000000..2e1e60b2f5
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/MetadataOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class MetadataOptionsConverter :
+        ConcreteSyntaxTreeNodes.MetadataOptions.Visitor<
+            AbstractSyntaxTreeNodes.MetadataOptions,
+            Void>
+    {
+        private MetadataOptionsConverter()
+        {
+        }
+
+        public static MetadataOptionsConverter Default { get; } = new MetadataOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/OdataRelativeUriConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/OdataRelativeUriConverter.cs
new file mode 100644
index 0000000000..c4fa62991f
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/OdataRelativeUriConverter.cs
@@ -0,0 +1,130 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class OdataRelativeUriConverter :
+        ConcreteSyntaxTreeNodes.OdataRelativeUri.Visitor<
+            AbstractSyntaxTreeNodes.OdataRelativeUri,
+            Void>
+    {
+        private readonly BatchOptionsConverter batchOptionsCstToAstTranslator;
+        private readonly EntityOptionsConverter entityOptionsTranslator;
+        private readonly QualifiedEntityTypeNameConverter qualifiedEntityTypeNameTranslator;
+        private readonly EntityCastOptionsConverter entityCastOptionsTranslator;
+        private readonly MetadataOptionsConverter metadataOptionsTranslator;
+        private readonly ContextConverter contextTranslator;
+        private readonly ResourcePathConverter resourcePathTranslator;
+        private readonly QueryOptionsConverter queryOptionsTranslator;
+
+        private OdataRelativeUriConverter(
+            BatchOptionsConverter batchOptionsCstToAstTranslator,
+            EntityOptionsConverter entityOptionsTranslator,
+            QualifiedEntityTypeNameConverter qualifiedEntityTypeNameTranslator,
+            EntityCastOptionsConverter entityCastOptionsTranslator,
+            MetadataOptionsConverter metadataOptionsTranslator,
+            ContextConverter contextTranslator,
+            ResourcePathConverter resourcePathTranslator,
+            QueryOptionsConverter queryOptionsTranslator)
+        {
+            this.batchOptionsCstToAstTranslator = batchOptionsCstToAstTranslator;
+            this.entityOptionsTranslator = entityOptionsTranslator;
+            this.qualifiedEntityTypeNameTranslator = qualifiedEntityTypeNameTranslator;
+            this.entityCastOptionsTranslator = entityCastOptionsTranslator;
+            this.metadataOptionsTranslator = metadataOptionsTranslator;
+            this.contextTranslator = contextTranslator;
+            this.resourcePathTranslator = resourcePathTranslator;
+            this.queryOptionsTranslator = queryOptionsTranslator;
+        }
+
+        public static OdataRelativeUriConverter Default { get; } = new OdataRelativeUriConverter(
+            BatchOptionsConverter.Default,
+            EntityOptionsConverter.Default,
+            QualifiedEntityTypeNameConverter.Default,
+            EntityCastOptionsConverter.Default,
+            MetadataOptionsConverter.Default,
+            ContextConverter.Default,
+            ResourcePathConverter.Default,
+            QueryOptionsConverter.Default);
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.BatchOnly node,
+            Void context)
+        {
+            return AbstractSyntaxTreeNodes.OdataRelativeUri.BatchOnly.Instance;
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.BatchWithOptions node,
+            Void context)
+        {
+            var batchOptions = this.batchOptionsCstToAstTranslator.Visit(node.BatchOptions, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.BatchWithOptions(batchOptions);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.EntityWithOptions node,
+            Void context)
+        {
+            var entityOptions = this.entityOptionsTranslator.Visit(node.EntityOptions, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.EntityWithOptions(entityOptions);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.EntityWithCast node,
+            Void context)
+        {
+            var qualifiedEntityTypeName = this.qualifiedEntityTypeNameTranslator.Visit(node.QualifiedEntityTypeName, context);
+            var entityCastOptions = this.entityCastOptionsTranslator.Visit(node.EntityCastOptions, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.EntityWithCast(qualifiedEntityTypeName, entityCastOptions);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataOnly node,
+            Void context)
+        {
+            return AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataOnly.Instance;
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptions node,
+            Void context)
+        {
+            var metadataOptions = this.metadataOptionsTranslator.Visit(node.MetadataOptions, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptions(metadataOptions);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataWithContext node,
+            Void context)
+        {
+            var metadataContext = this.contextTranslator.Visit(node.Context, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataWithContext(metadataContext);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptionsAndContext node,
+            Void context)
+        {
+            var metadataOptions = this.metadataOptionsTranslator.Visit(node.MetadataOptions, context);
+            var metadataContext = this.contextTranslator.Visit(node.Context, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.MetadataWithOptionsAndContext(metadataOptions, metadataContext);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.ResourcePathOnly node,
+            Void context)
+        {
+            var resourcePath = this.resourcePathTranslator.Visit(node.ResourcePath, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.ResourcePathOnly(resourcePath);
+        }
+
+        public override AbstractSyntaxTreeNodes.OdataRelativeUri Accept(
+            ConcreteSyntaxTreeNodes.OdataRelativeUri.ResourcePathWithQueryOptions node,
+            Void context)
+        {
+            var resourcePath = this.resourcePathTranslator.Visit(node.ResourcePath, context);
+            var queryOptions = this.queryOptionsTranslator.Visit(node.QueryOptions, context);
+            return new AbstractSyntaxTreeNodes.OdataRelativeUri.ResourcePathWithQueryOptions(resourcePath, queryOptions);
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/QualifiedEntityTypeNameConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/QualifiedEntityTypeNameConverter.cs
new file mode 100644
index 0000000000..4c3e170b23
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/QualifiedEntityTypeNameConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class QualifiedEntityTypeNameConverter :
+        ConcreteSyntaxTreeNodes.QualifiedEntityTypeName.Visitor<
+            AbstractSyntaxTreeNodes.QualifiedEntityTypeName,
+            Void>
+    {
+        private QualifiedEntityTypeNameConverter()
+        {
+        }
+
+        public static QualifiedEntityTypeNameConverter Default { get; } = new QualifiedEntityTypeNameConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/QueryOptionsConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/QueryOptionsConverter.cs
new file mode 100644
index 0000000000..e078663d28
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/QueryOptionsConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class QueryOptionsConverter :
+        ConcreteSyntaxTreeNodes.QueryOptions.Visitor<
+            AbstractSyntaxTreeNodes.QueryOptions,
+            Void>
+    {
+        private QueryOptionsConverter()
+        {
+        }
+
+        public static QueryOptionsConverter Default { get; } = new QueryOptionsConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/CstToAstConverters/ResourcePathConverter.cs b/odata/Root/OdataResourcePath/CstToAstConverters/ResourcePathConverter.cs
new file mode 100644
index 0000000000..b2e52d34a0
--- /dev/null
+++ b/odata/Root/OdataResourcePath/CstToAstConverters/ResourcePathConverter.cs
@@ -0,0 +1,16 @@
+namespace Root.OdataResourcePath.CstToAstConverters
+{
+    using Root;
+
+    public sealed class ResourcePathConverter :
+        ConcreteSyntaxTreeNodes.ResourcePath.Visitor<
+            AbstractSyntaxTreeNodes.ResourcePath,
+            Void>
+    {
+        private ResourcePathConverter()
+        {
+        }
+
+        public static ResourcePathConverter Default { get; } = new ResourcePathConverter();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/SyntacticCstNodes/contextfree.abnf b/odata/Root/OdataResourcePath/SyntacticCstNodes/contextfree.abnf
new file mode 100644
index 0000000000..0334a6cff0
--- /dev/null
+++ b/odata/Root/OdataResourcePath/SyntacticCstNodes/contextfree.abnf
@@ -0,0 +1,134 @@
+
+
+; TODO TODO TODO TODO TODO TODO TODO TODO
+; "evaluate" the ABNF to show where expression sequences are allowed by multiple paths through the ABNF; these are the "ambiguities"
+; use literals and odataIdentifier as "terminal" and re-evaluate if there are other teminals that are needed (keyPathLiteral for example seems likely)
+; 
+; how do you want to distinguish between things like odataIdentifier and keyPathLiteral? you could
+; 1. treat them both as "identifier" or something
+; 2. distinguish them as individual things (but this might lead to cases where a keyPathLiteral is labeled as an odataIdentifier)
+; 3. have a DU that says "we *know* this was a keyPathLiteral" and "we *know* this was an odataIdentifier" and "it's possible this was a keyPathLiteral or an odataIdentifier, we can't distinguish"
+; TODO TODO TODO TODO TODO TODO TODO TODO
+
+
+
+odataRelativeUri	= '$batch' [ "?" batchOptions ]
+					/ '$entity' "?" entityOptions
+					/ '$entity' "/" qualifiedTypeName ? entityCastOptions
+					/ '$metadata' [ "?" metadataOptions ] [ context ]
+					/ resourcePath [ "?" queryOptions ]
+
+batchOptions	= batchOption *( "&" batchOption )
+
+; TODO do `odataRelativeUri`s that start with $entity 
+; TODO do `odataRelativeUri`s that start with $metadata
+
+resourcePath	= one
+				/ TODO
+				/ '$all' [ "/" qualifiedTypeName ]	; '$all' [ "/" qualifiedTypeName ]
+
+; entitySetName [ collectionNavigation ]
+one	= odataIdentifier [ "/" qualifiedTypeName ] [ simpleKey ] ; TODO finish this
+		/ odataIdentifier [ "/" qualifiedTypeName ] [ compoundKey ] ; TODO finish this
+		/ ; TODO finsih this
+
+batchOption	= format
+			/ customQueryOption
+
+format	= ( "$format" / "format" ) EQ
+		  ( "atom"
+		  / "json"
+		  / "xml"
+		  / 1*pchar "/" 1*pchar
+		  )
+
+customQueryOption	= customName [ EQ customValue ]
+
+customName	= qchar-no-AMP-EQ-AT-DOLLAR *( qchar-no-AMP-EQ )
+
+customValue	= *( qchar-no-AMP )
+
+qualifiedTypeName	= namespace "." entityTypeName
+
+namespace	= namespacePart *( "." namespacePart )
+
+namespacePart = odataIdentifier
+
+entityTypeName	= odataIdentifier
+
+odataIdentifier	= identifierLeadingCharacter *127identifierCharacter
+
+identifierLeadingCharacter	= ALPHA / "_" ; plus Unicode characters from the categories L or Nl
+
+identifierCharacter	= ALPHA / "_" / DIGIT ; plus Unicode characters from the categories L, Nl, Nd, Mn, Mc, Pc, or Cf
+
+pchar	= unreserved
+		/ pct-encoded
+		/ sub-delims
+		/ ":"
+		/ "@"
+
+unreserved	= ALPHA
+			/ DIGIT
+			/ "-"
+			/ "."
+			/ "_"
+			/ "~"
+
+pct-encoded	= "%" HEXDIG HEXDIG
+
+sub-delims	= "$" 
+			/ "&"
+			/ "'"
+			/ "="
+			/ other-delims
+
+other-delims	= "!"
+				/ "("
+				/ ")"
+				/ "*"
+				/ "+"
+				/ ","
+				/ ";"
+
+qchar-no-AMP	= unreserved
+				/ pct-encoded
+				/ other-delims
+				/ ":"
+				/ "@"
+				/ "/"
+				/ "?"
+				/ "$"
+				/ "'"
+				/ "="
+
+qchar-no-AMP-EQ	= unreserved
+				/ pct-encoded
+				/ other-delims
+				/ ":"
+				/ "@"
+				/ "/"
+				/ "?"
+				/ "$"
+				/ "'"
+qchar-no-AMP-EQ-AT-DOLLAR	= unreserved
+							/ pct-encoded
+							/ other-delims
+							/ ":"
+							/ "/"
+							/ "?"
+							/ "'"
+
+;------------------------------------------------------------------------------
+; 9. Punctuation
+;------------------------------------------------------------------------------
+
+EQ	= "="
+
+;------------------------------------------------------------------------------
+; C. ABNF core definitions [RFC5234]
+;------------------------------------------------------------------------------
+
+ALPHA	= %x41-5A / %x61-7A 
+DIGIT	= %x30-39 
+HEXDIG = DIGIT / A-to-F
\ No newline at end of file
diff --git a/odata/Root/OdataResourcePath/Transcribers/BatchOptionsTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/BatchOptionsTranscriber.cs
new file mode 100644
index 0000000000..85b49849db
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/BatchOptionsTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class BatchOptionsTranscriber : BatchOptions.Visitor<Void, StringBuilder>
+    {
+        private BatchOptionsTranscriber()
+        {
+        }
+
+        public static BatchOptionsTranscriber Default { get; } = new BatchOptionsTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/BatchTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/BatchTranscriber.cs
new file mode 100644
index 0000000000..fe215768a3
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/BatchTranscriber.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class BatchTranscriber
+    {
+        private BatchTranscriber()
+        {
+        }
+
+        public static BatchTranscriber Default { get; } = new BatchTranscriber();
+
+        public void Transcribe(Batch node, StringBuilder context)
+        {
+            context.Append("$batch");
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/ContextTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/ContextTranscriber.cs
new file mode 100644
index 0000000000..350b312857
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/ContextTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class ContextTranscriber : Context.Visitor<Void, StringBuilder>
+    {
+        private ContextTranscriber()
+        {
+        }
+
+        public static ContextTranscriber Default { get; } = new ContextTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/EntityCastOptionsTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/EntityCastOptionsTranscriber.cs
new file mode 100644
index 0000000000..76505fc4f0
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/EntityCastOptionsTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class EntityCastOptionsTranscriber : EntityCastOptions.Visitor<Void, StringBuilder>
+    {
+        private EntityCastOptionsTranscriber()
+        {
+        }
+
+        public static EntityCastOptionsTranscriber Default { get; } = new EntityCastOptionsTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/EntityOptionsTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/EntityOptionsTranscriber.cs
new file mode 100644
index 0000000000..b9c2418e6c
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/EntityOptionsTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class EntityOptionsTranscriber : EntityOptions.Visitor<Void, StringBuilder>
+    {
+        private EntityOptionsTranscriber()
+        {
+        }
+
+        public static EntityOptionsTranscriber Default { get; } = new EntityOptionsTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/EntityTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/EntityTranscriber.cs
new file mode 100644
index 0000000000..27b227e108
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/EntityTranscriber.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class EntityTranscriber
+    {
+        private EntityTranscriber()
+        {
+        }
+
+        public static EntityTranscriber Default { get; } = new EntityTranscriber();
+
+        public void Transcribe(Entity node, StringBuilder context)
+        {
+            context.Append("entity");
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/MetadataOptionsTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/MetadataOptionsTranscriber.cs
new file mode 100644
index 0000000000..576b892d9c
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/MetadataOptionsTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class MetadataOptionsTranscriber : MetadataOptions.Visitor<Void, StringBuilder>
+    {
+        private MetadataOptionsTranscriber()
+        {
+        }
+
+        public static MetadataOptionsTranscriber Default { get; } = new MetadataOptionsTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/MetadataTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/MetadataTranscriber.cs
new file mode 100644
index 0000000000..6ab667f723
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/MetadataTranscriber.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class MetadataTranscriber
+    {
+        private MetadataTranscriber()
+        {
+        }
+
+        public static MetadataTranscriber Default { get; } = new MetadataTranscriber();
+
+        public void Transcribe(Metadata node, StringBuilder context)
+        {
+            context.Append("$metadata");
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/OdataRelativeUriTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/OdataRelativeUriTranscriber.cs
new file mode 100644
index 0000000000..809beb37ec
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/OdataRelativeUriTranscriber.cs
@@ -0,0 +1,144 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class OdataRelativeUriTranscriber : OdataRelativeUri.Visitor<Void, StringBuilder>
+    {
+        private readonly BatchTranscriber batchTranscriber;
+        private readonly QuestionMarkTranscriber questionMarkTranscriber;
+        private readonly BatchOptionsTranscriber batchOptionsTranscriber;
+        private readonly EntityTranscriber entityTranscriber;
+        private readonly EntityOptionsTranscriber entityOptionsTranscriber;
+        private readonly SlashTranscriber slashTranscriber;
+        private readonly QualifiedEntityTypeNameTranscriber qualifiedEntityTypeNameTranscriber;
+        private readonly EntityCastOptionsTranscriber entityCastOptionsTranscriber;
+        private readonly MetadataTranscriber metadataTranscriber;
+        private readonly MetadataOptionsTranscriber metadataOptionsTranscriber;
+        private readonly ContextTranscriber contextTranscriber;
+        private readonly ResourcePathTranscriber resourcePathTranscriber;
+        private readonly QueryOptionsTranscriber queryOptionsTranscriber;
+
+        private OdataRelativeUriTranscriber(
+            BatchTranscriber batchTranscriber,
+            QuestionMarkTranscriber questionMarkTranscriber,
+            BatchOptionsTranscriber batchOptionsTranscriber,
+            EntityTranscriber entityTranscriber,
+            EntityOptionsTranscriber entityOptionsTranscriber,
+            SlashTranscriber slashTranscriber,
+            QualifiedEntityTypeNameTranscriber qualifiedEntityTypeNameTranscriber,
+            EntityCastOptionsTranscriber entityCastOptionsTranscriber,
+            MetadataTranscriber metadataTranscriber,
+            MetadataOptionsTranscriber metadataOptionsTranscriber,
+            ContextTranscriber contextTranscriber,
+            ResourcePathTranscriber resourcePathTranscriber,
+            QueryOptionsTranscriber queryOptionsTranscriber)
+        {
+            this.batchTranscriber = batchTranscriber;
+            this.questionMarkTranscriber = questionMarkTranscriber;
+            this.batchOptionsTranscriber = batchOptionsTranscriber;
+            this.entityTranscriber = entityTranscriber;
+            this.entityOptionsTranscriber = entityOptionsTranscriber;
+            this.slashTranscriber = slashTranscriber;
+            this.qualifiedEntityTypeNameTranscriber = qualifiedEntityTypeNameTranscriber;
+            this.entityCastOptionsTranscriber = entityCastOptionsTranscriber;
+            this.metadataTranscriber = metadataTranscriber;
+            this.metadataOptionsTranscriber = metadataOptionsTranscriber;
+            this.contextTranscriber = contextTranscriber;
+            this.resourcePathTranscriber = resourcePathTranscriber;
+            this.queryOptionsTranscriber = queryOptionsTranscriber;
+        }
+
+        public static OdataRelativeUriTranscriber Default { get; } = new OdataRelativeUriTranscriber(
+            BatchTranscriber.Default,
+            QuestionMarkTranscriber.Default,
+            BatchOptionsTranscriber.Default,
+            EntityTranscriber.Default,
+            EntityOptionsTranscriber.Default,
+            SlashTranscriber.Default,
+            QualifiedEntityTypeNameTranscriber.Default,
+            EntityCastOptionsTranscriber.Default,
+            MetadataTranscriber.Default,
+            MetadataOptionsTranscriber.Default,
+            ContextTranscriber.Default,
+            ResourcePathTranscriber.Default,
+            QueryOptionsTranscriber.Default);
+
+        public override Void Accept(OdataRelativeUri.BatchOnly node, StringBuilder context)
+        {
+            this.batchTranscriber.Transcribe(node.Batch, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.BatchWithOptions node, StringBuilder context)
+        {
+            this.batchTranscriber.Transcribe(node.Batch, context);
+            this.questionMarkTranscriber.Transcribe(node.QuestionMark, context);
+            this.batchOptionsTranscriber.Visit(node.BatchOptions, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.EntityWithOptions node, StringBuilder context)
+        {
+            this.entityTranscriber.Transcribe(node.Entity, context);
+            this.questionMarkTranscriber.Transcribe(node.QuestionMark, context);
+            this.entityOptionsTranscriber.Visit(node.EntityOptions, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.EntityWithCast node, StringBuilder context)
+        {
+            this.entityTranscriber.Transcribe(node.Entity, context);
+            this.slashTranscriber.Transcribe(node.Slash, context);
+            this.qualifiedEntityTypeNameTranscriber.Visit(node.QualifiedEntityTypeName, context);
+            this.questionMarkTranscriber.Transcribe(node.QuestionMark, context);
+            this.entityCastOptionsTranscriber.Visit(node.EntityCastOptions, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.MetadataOnly node, StringBuilder context)
+        {
+            this.metadataTranscriber.Transcribe(node.Metadata, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.MetadataWithOptions node, StringBuilder context)
+        {
+            this.metadataTranscriber.Transcribe(node.Metadata, context);
+            this.questionMarkTranscriber.Transcribe(node.QuestionMark, context);
+            this.metadataOptionsTranscriber.Visit(node.MetadataOptions, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.MetadataWithContext node, StringBuilder context)
+        {
+            this.metadataTranscriber.Transcribe(node.Metadata, context);
+            this.contextTranscriber.Visit(node.Context, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.MetadataWithOptionsAndContext node, StringBuilder context)
+        {
+            this.metadataTranscriber.Transcribe(node.Metadata, context);
+            this.questionMarkTranscriber.Transcribe(node.QuestionMark, context);
+            this.metadataOptionsTranscriber.Visit(node.MetadataOptions, context);
+            this.contextTranscriber.Visit(node.Context, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.ResourcePathOnly node, StringBuilder context)
+        {
+            this.resourcePathTranscriber.Visit(node.ResourcePath, context);
+            return default;
+        }
+
+        public override Void Accept(OdataRelativeUri.ResourcePathWithQueryOptions node, StringBuilder context)
+        {
+            this.resourcePathTranscriber.Visit(node.ResourcePath, context);
+            this.questionMarkTranscriber.Transcribe(node.QuestionMark, context);
+            this.queryOptionsTranscriber.Visit(node.QueryOptions, context);
+            return default;
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/QualifiedEntityTypeNameTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/QualifiedEntityTypeNameTranscriber.cs
new file mode 100644
index 0000000000..781b50da0c
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/QualifiedEntityTypeNameTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class QualifiedEntityTypeNameTranscriber : QualifiedEntityTypeName.Visitor<Void, StringBuilder>
+    {
+        private QualifiedEntityTypeNameTranscriber()
+        {
+        }
+
+        public static QualifiedEntityTypeNameTranscriber Default { get; } = new QualifiedEntityTypeNameTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/QueryOptionsTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/QueryOptionsTranscriber.cs
new file mode 100644
index 0000000000..09d6446b82
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/QueryOptionsTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class QueryOptionsTranscriber : QueryOptions.Visitor<Void, StringBuilder>
+    {
+        private QueryOptionsTranscriber()
+        {
+        }
+
+        public static QueryOptionsTranscriber Default { get; } = new QueryOptionsTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/QuestionMarkTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/QuestionMarkTranscriber.cs
new file mode 100644
index 0000000000..c0eff9e41b
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/QuestionMarkTranscriber.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class QuestionMarkTranscriber
+    {
+        private QuestionMarkTranscriber()
+        {
+        }
+
+        public static QuestionMarkTranscriber Default { get; } = new QuestionMarkTranscriber();
+
+        public void Transcribe(QuestionMark node, StringBuilder context)
+        {
+            context.Append('?');
+        }
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/ResourcePathTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/ResourcePathTranscriber.cs
new file mode 100644
index 0000000000..1a06c428e4
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/ResourcePathTranscriber.cs
@@ -0,0 +1,15 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class ResourcePathTranscriber : ResourcePath.Visitor<Void, StringBuilder>
+    {
+        private ResourcePathTranscriber()
+        {
+        }
+
+        public static ResourcePathTranscriber Default { get; } = new ResourcePathTranscriber();
+    }
+}
diff --git a/odata/Root/OdataResourcePath/Transcribers/SlashTranscriber.cs b/odata/Root/OdataResourcePath/Transcribers/SlashTranscriber.cs
new file mode 100644
index 0000000000..ffc623296b
--- /dev/null
+++ b/odata/Root/OdataResourcePath/Transcribers/SlashTranscriber.cs
@@ -0,0 +1,20 @@
+namespace Root.OdataResourcePath.Transcribers
+{
+    using System.Text;
+
+    using Root.OdataResourcePath.ConcreteSyntaxTreeNodes;
+
+    public sealed class SlashTranscriber
+    {
+        private SlashTranscriber()
+        {
+        }
+
+        public static SlashTranscriber Default { get; } = new SlashTranscriber();
+
+        public void Transcribe(Slash node, StringBuilder context)
+        {
+            context.Append("/");
+        }
+    }
+}
diff --git a/odata/Root/Parser.cs b/odata/Root/Parser.cs
new file mode 100644
index 0000000000..766e816b4a
--- /dev/null
+++ b/odata/Root/Parser.cs
@@ -0,0 +1,16 @@
+namespace Root
+{
+    using Sprache;
+    using System.Linq;
+
+    /// <summary>
+    /// TODO put this in the right folder and namespace
+    /// </summary>
+    public static class Parser
+    {
+        public static Parser<T> None<T>(string errorMessage)
+        {
+            return input => Result.Failure<T>(input, errorMessage, Enumerable.Empty<string>());
+        }
+    }
+}
diff --git a/odata/Root/Void.cs b/odata/Root/Void.cs
new file mode 100644
index 0000000000..b0aab22aa1
--- /dev/null
+++ b/odata/Root/Void.cs
@@ -0,0 +1,9 @@
+namespace Root
+{
+    /// <summary>
+    /// TODO put this in the right folder and namespace
+    /// </summary>
+    public struct Void
+    {
+    }
+}
diff --git a/odata/odata.abnf b/odata/odata.abnf
new file mode 100644
index 0000000000..348fc52fd0
--- /dev/null
+++ b/odata/odata.abnf
@@ -0,0 +1,1264 @@
+;------------------------------------------------------------------------------
+; OData ABNF Construction Rules Version 4.01
+;------------------------------------------------------------------------------
+; Working Draft 03
+; 28 September 2017
+;------------------------------------------------------------------------------
+;
+;     OData Version 4.01
+;     Committee Specification 01
+;     30 January 2018
+;     Copyright (c) OASIS Open 2018. All Rights Reserved.
+;     Source: http://docs.oasis-open.org/odata/odata/v4.01/cs01/abnf/
+;     Latest version of narrative specification: http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-protocol.html
+;     TC IPR Statement: https://www.oasis-open.org/committees/odata/ipr.php
+;
+; Technical Committee:
+;   OASIS Open Data Protocol (OData) TC
+;   https://www.oasis-open.org/committees/odata
+;
+; Chairs:
+;   - Ralf Handl (ralf.handl@sap.com), SAP SE
+;   - Ram Jeyaraman (Ram.Jeyaraman@microsoft.com), Microsoft
+;
+; Editors:
+;   - Ralf Handl (ralf.handl@sap.com), SAP SE
+;   - Michael Pizzo (mikep@microsoft.com), Microsoft
+;   - Martin Zurmuehl (martin.zurmuehl@sap.com), SAP SE
+;
+; Additional artifacts: 
+;   This grammar is one component of a Work Product which consists of:
+;   - OData Version 4.01 Part 1: Protocol
+;   - OData Version 4.01 Part 2: URL Conventions
+;   - OData ABNF Construction Rules Version 4.01 (this document)
+;   - OData ABNF Test Cases Version 4.01
+;
+; Related work:
+;   This specification replaces or supersedes:
+;   - OData ABNF Construction Rules Version 4.0
+;   This work product is related to
+;   - OData Common Schema Definition Language (CSDL) JSON Representation Version 4.01
+;   - OData Common Schema Definition Language (CSDL) XML Representation Version 4.01
+;   - OData JSON Format Version 4.01
+;
+; Abstract:
+;   The Open Data Protocol (OData) enables the creation of REST-based data
+;   services, which allow resources, identified using Uniform Resource
+;   Identifiers (URLs) and defined in a data model, to be published and 
+;   edited by Web clients using simple HTTP messages. This document defines
+;   the URL syntax for requests and the serialization format for primitive 
+;   literals in request and response payloads.
+;
+; Overview:
+;   This grammar uses the ABNF defined in RFC5234 with one extension: literals 
+;   enclosed in single quotes (e.g. "$metadata") are treated case-sensitive. 
+;
+;   The following rules assume that URIs have been percent-encoding normalized
+;   as described in section 6.2.2.2 of RFC3986 
+;   (http://tools.ietf.org/html/rfc3986#section-6.2.2.2)
+;   before applying the grammar to them, i.e. all characters in the unreserved 
+;   set (see rule "unreserved" below) are plain literals and NOT
+;   percent-encoded. 
+;
+;   For characters outside the unreserved set the rules explicitly state 
+;   whether the percent-encoded representation is treated identical to the
+;   plain literal representation.
+; 
+;   One prominent example is the single quote that delimits OData primitive  
+;   type literals: %27 and " are treated identically, so a single quote within 
+;   a string literal is "encoded" as two consecutive single quotes in either
+;   literal or percent-encoded representation.
+;
+; Contents:
+;   1. Resource Path
+;   2. Query Options
+;   3. Context URL Fragments
+;   4. Expressions
+;   5. JSON format for function parameters
+;   6. Names and identifiers
+;   7. Literal Data Values
+;   8. Header values
+;   9. Punctuation
+;
+;   A. URI syntax [RFC3986]
+;   B. IRI syntax [RFC3986]
+;   C. ABNF core definitions [RFC5234]
+;
+;------------------------------------------------------------------------------
+dummyStartRule = odataUri / header / primitiveValue ; just to please the test parser
+;------------------------------------------------------------------------------
+
+
+odataUri = serviceRoot [ odataRelativeUri ]  
+
+serviceRoot = ( "https" / "http" )                    ; Note: case-insensitive 
+              "://" host [ ":" port ]
+              "/" *( segment-nz "/" )
+
+; Note: dollar-prefixed path segments are case-sensitive!
+odataRelativeUri = "$batch"  [ "?" batchOptions ]
+                 / "$entity" "?" entityOptions  
+                 / "$entity" "/" qualifiedEntityTypeName "?" entityCastOptions  
+                 / "$metadata" [ "?" metadataOptions ] [ context ]
+                 / resourcePath [ "?" queryOptions ]
+
+
+;------------------------------------------------------------------------------
+; 1. Resource Path
+;------------------------------------------------------------------------------
+
+resourcePath = entitySetName                  [ collectionNavigation ] 
+             / singletonEntity                [ singleNavigation ]
+             / actionImportCall 
+             / entityColFunctionImportCall    [ collectionNavigation ] 
+             / entityFunctionImportCall       [ singleNavigation ] 
+             / complexColFunctionImportCall   [ complexColPath ] 
+             / complexFunctionImportCall      [ complexPath ] 
+             / primitiveColFunctionImportCall [ primitiveColPath ] 
+             / primitiveFunctionImportCall    [ primitivePath ] 
+             / functionImportCallNoParens
+             / crossjoin
+             / "$all"                         [ "/" qualifiedEntityTypeName ]
+
+collectionNavigation = [ "/" qualifiedEntityTypeName ] [ collectionNavPath ]
+collectionNavPath    = keyPredicate [ singleNavigation ]
+                     / filterInPath [ collectionNavigation ]
+                     / each [ boundOperation ]
+                     / boundOperation
+                     / count
+                     / ref
+
+keyPredicate     = simpleKey / compoundKey / keyPathSegments
+simpleKey        = OPEN ( parameterAlias / keyPropertyValue ) CLOSE
+compoundKey      = OPEN keyValuePair *( COMMA keyValuePair ) CLOSE
+keyValuePair     = ( primitiveKeyProperty / keyPropertyAlias  ) EQ ( parameterAlias / keyPropertyValue )
+keyPropertyValue = primitiveLiteral
+keyPropertyAlias = odataIdentifier
+keyPathSegments  = 1*( "/" keyPathLiteral )
+keyPathLiteral   = *pchar
+
+singleNavigation = [ "/" qualifiedEntityTypeName ] 
+                   [ "/" propertyPath
+                   / boundOperation
+                   / ref 
+                   / value  ; request the media resource of a media entity 
+                   ]
+
+propertyPath = entityColNavigationProperty [ collectionNavigation ]
+             / entityNavigationProperty    [ singleNavigation ]
+             / complexColProperty          [ complexColPath ]
+             / complexProperty             [ complexPath ]
+             / primitiveColProperty        [ primitiveColPath ]
+             / primitiveProperty           [ primitivePath ]
+             / streamProperty              [ boundOperation ]
+
+primitiveColPath = count / boundOperation / ordinalIndex
+
+primitivePath  = value / boundOperation
+
+complexColPath = ordinalIndex
+               / [ "/" qualifiedComplexTypeName ] [ count / boundOperation ]
+
+complexPath    = [ "/" qualifiedComplexTypeName ] 
+                 [ "/" propertyPath 
+                 / boundOperation
+                 ]
+                 
+filterInPath = "/$filter" EQ parameterAlias
+
+each  = "/$each"
+count = "/$count"
+ref   = "/$ref"
+value = "/$value"
+
+ordinalIndex = "/" 1*DIGIT
+
+; boundOperation segments can only be composed if the type of the previous segment 
+; matches the type of the first parameter of the action or function being called.
+; Note that the rule name reflects the return type of the function.
+boundOperation = "/" ( boundActionCall
+                     / boundEntityColFunctionCall    [ collectionNavigation ] 
+                     / boundEntityFunctionCall       [ singleNavigation ] 
+                     / boundComplexColFunctionCall   [ complexColPath ] 
+                     / boundComplexFunctionCall      [ complexPath ]
+                     / boundPrimitiveColFunctionCall [ primitiveColPath ] 
+                     / boundPrimitiveFunctionCall    [ primitivePath ] 
+                     / boundFunctionCallNoParens
+                     )
+
+actionImportCall = actionImport
+boundActionCall  = namespace "." action
+                   ; with the added restriction that the binding parameter MUST be either an entity or collection of entities
+                   ; and is specified by reference using the URI immediately preceding (to the left) of the boundActionCall
+
+; The following boundXxxFunctionCall rules have the added restrictions that
+;  - the function MUST support binding, and 
+;  - the binding parameter type MUST match the type of resource identified by the 
+;    URI immediately preceding (to the left) of the boundXxxFunctionCall, and
+;  - the functionParameters MUST NOT include the bindingParameter.
+boundEntityFunctionCall       = namespace "." entityFunction       functionParameters
+boundEntityColFunctionCall    = namespace "." entityColFunction    functionParameters
+boundComplexFunctionCall      = namespace "." complexFunction      functionParameters
+boundComplexColFunctionCall   = namespace "." complexColFunction   functionParameters
+boundPrimitiveFunctionCall    = namespace "." primitiveFunction    functionParameters
+boundPrimitiveColFunctionCall = namespace "." primitiveColFunction functionParameters
+
+boundFunctionCallNoParens     = namespace "." entityFunction
+                              / namespace "." entityColFunction
+                              / namespace "." complexFunction
+                              / namespace "." complexColFunction
+                              / namespace "." primitiveFunction
+                              / namespace "." primitiveColFunction
+
+entityFunctionImportCall       = entityFunctionImport       functionParameters
+entityColFunctionImportCall    = entityColFunctionImport    functionParameters
+complexFunctionImportCall      = complexFunctionImport      functionParameters
+complexColFunctionImportCall   = complexColFunctionImport   functionParameters
+primitiveFunctionImportCall    = primitiveFunctionImport    functionParameters
+primitiveColFunctionImportCall = primitiveColFunctionImport functionParameters
+
+functionImportCallNoParens     = entityFunctionImport
+                               / entityColFunctionImport
+                               / complexFunctionImport
+                               / complexColFunctionImport
+                               / primitiveFunctionImport
+                               / primitiveColFunctionImport
+
+functionParameters = OPEN [ functionParameter *( COMMA functionParameter ) ] CLOSE
+functionParameter  = parameterName EQ ( parameterAlias / primitiveLiteral )
+parameterName      = odataIdentifier
+parameterAlias     = AT odataIdentifier 
+
+crossjoin = "$crossjoin" OPEN
+            entitySetName *( COMMA entitySetName )
+            CLOSE
+
+
+;------------------------------------------------------------------------------
+; 2. Query Options
+;------------------------------------------------------------------------------
+
+queryOptions = queryOption *( "&" queryOption )        
+queryOption  = systemQueryOption  
+             / aliasAndValue 
+             / nameAndValue
+             / customQueryOption  
+
+batchOptions = batchOption *( "&" batchOption )   
+batchOption  = format
+             /customQueryOption   
+             
+metadataOptions = metadataOption *( "&" metadataOption )   
+metadataOption  = format
+                /customQueryOption   
+
+entityOptions  = *( entityIdOption "&" ) id *( "&" entityIdOption )
+entityIdOption = format
+               / customQueryOption
+entityCastOptions = *( entityCastOption "&" ) id *( "&" entityCastOption )
+entityCastOption  = entityIdOption
+                  / expand 
+                  / select
+
+id = ( "$id" / "id" ) EQ IRI-in-query       
+
+systemQueryOption = compute
+                  / deltatoken
+                  / expand 
+                  / filter 
+                  / format 
+                  / id
+                  / inlinecount 
+                  / orderby 
+                  / schemaversion
+                  / search
+                  / select 
+                  / skip 
+                  / skiptoken
+                  / top 
+                  / index
+
+compute          = ( "$compute" / "compute" ) EQ computeItem *( COMMA computeItem )
+computeItem      = commonExpr RWS "as" RWS computedProperty
+computedProperty = odataIdentifier         
+
+expand            = ( "$expand" / "expand" ) EQ expandItem *( COMMA expandItem )
+expandItem        = STAR [ ref / OPEN levels CLOSE ]
+                  / "$value"
+                  / expandPath
+                    [ ref   [ OPEN expandRefOption   *( SEMI expandRefOption   ) CLOSE ]
+                    / count [ OPEN expandCountOption *( SEMI expandCountOption ) CLOSE ]
+                    /         OPEN expandOption      *( SEMI expandOption      ) CLOSE 
+                    ]
+expandPath        = [ ( qualifiedEntityTypeName / qualifiedComplexTypeName ) "/" ] 
+                    *( ( complexProperty / complexColProperty ) "/" [ qualifiedComplexTypeName "/" ] )
+                    ( STAR / streamProperty / navigationProperty [ "/" qualifiedEntityTypeName ] )
+expandCountOption = filter
+                  / search
+expandRefOption   = expandCountOption
+                  / orderby
+                  / skip 
+                  / top 
+                  / inlinecount
+expandOption      = expandRefOption
+                  / select 
+                  / expand
+                  / compute
+                  / levels
+                  / aliasAndValue
+                
+levels = ( "$levels" / "levels" ) EQ ( oneToNine *DIGIT / "max" )
+
+filter = ( "$filter" / "filter" ) EQ boolCommonExpr
+
+orderby     = ( "$orderby" / "orderby" ) EQ orderbyItem *( COMMA orderbyItem )
+orderbyItem = commonExpr [ RWS ( "asc" / "desc" ) ]
+
+skip = ( "$skip" / "skip" ) EQ 1*DIGIT
+top  = ( "$top"  / "top"  ) EQ 1*DIGIT
+
+index  = ( "$index" / "index" ) EQ 1*DIGIT
+
+format = ( "$format" / "format" ) EQ
+         ( "atom"
+         / "json" 
+         / "xml"
+         / 1*pchar "/" 1*pchar ; <a data service specific value indicating a
+         )                     ; format specific to the specific data service> or
+                               ; <An IANA-defined [IANA-MMT] content type>
+                          
+inlinecount = ( "$count" / "count" ) EQ booleanValue
+
+schemaversion   = ( "$schemaversion" / "schemaversion" ) EQ ( STAR / 1*unreserved )
+
+search     = ( "$search" / "search" ) EQ BWS searchExpr
+searchExpr = ( OPEN BWS searchExpr BWS CLOSE
+             / searchTerm 
+             ) [ searchOrExpr
+               / searchAndExpr
+               ]
+
+searchOrExpr  = RWS "OR"  RWS searchExpr
+searchAndExpr = RWS [ "AND" RWS ] searchExpr
+
+searchTerm   = [ "NOT" RWS ] ( searchPhrase / searchWord )
+searchPhrase = quotation-mark 1*qchar-no-AMP-DQUOTE quotation-mark
+
+; A searchWord is a sequence of one or more letters, digits, commas, or dots.
+; This includes Unicode characters of categories L or N using UTF-8 and percent-encoding.
+; The words AND, OR, and NOT are not a valid searchWord.
+; Expressing this in ABNF is somewhat clumsy, so the following rule is overly generous.
+searchWord   = 1*( ALPHA / DIGIT / COMMA / "." / pct-encoded )
+
+select         = ( "$select" / "select" ) EQ selectItem *( COMMA selectItem )
+selectItem     = STAR
+               / allOperationsInSchema 
+               / [ ( qualifiedEntityTypeName / qualifiedComplexTypeName ) "/" ] 
+                 ( selectProperty
+                 / qualifiedActionName  
+                 / qualifiedFunctionName  
+                 )
+selectProperty = primitiveProperty  
+               / primitiveColProperty [ OPEN selectOptionPC *( SEMI selectOptionPC ) CLOSE ]
+               / navigationProperty
+               / selectPath [ OPEN selectOption *( SEMI selectOption ) CLOSE
+                            / "/" selectProperty 
+                            ]
+selectPath     = ( complexProperty / complexColProperty ) [ "/" qualifiedComplexTypeName ] 
+selectOptionPC = filter / search / inlinecount / orderby / skip / top 
+selectOption   = selectOptionPC
+               / compute / select / expand / aliasAndValue
+
+allOperationsInSchema = namespace "." STAR                 
+
+; The parameterNames uniquely identify the bound function overload
+; only if it has overloads.
+qualifiedActionName   = namespace "." action
+qualifiedFunctionName = namespace "." function [ OPEN parameterNames CLOSE ]
+
+; The names of all non-binding parameters, separated by commas 
+parameterNames = parameterName *( COMMA parameterName )
+
+deltatoken = "$deltatoken" EQ 1*( qchar-no-AMP )
+
+skiptoken = "$skiptoken" EQ 1*( qchar-no-AMP )
+
+aliasAndValue = parameterAlias EQ parameterValue
+
+nameAndValue = parameterName EQ parameterValue
+
+parameterValue = arrayOrObject
+               / commonExpr
+
+customQueryOption = customName [ EQ customValue ]
+customName        = qchar-no-AMP-EQ-AT-DOLLAR *( qchar-no-AMP-EQ ) 
+customValue       = *( qchar-no-AMP )
+
+     
+;------------------------------------------------------------------------------
+; 3. Context URL Fragments
+;------------------------------------------------------------------------------
+
+context         = "#" contextFragment
+contextFragment = "Collection($ref)"
+                / "$ref"
+                / "Collection(Edm.EntityType)"
+                / "Collection(Edm.ComplexType)"
+                / singletonEntity [ navigation *( containmentNavigation ) [ "/" qualifiedEntityTypeName ] ] [ selectList ]
+                / qualifiedTypeName [ selectList ]
+                / entitySet ( "/$deletedEntity" / "/$link" / "/$deletedLink" )
+                / entitySet keyPredicate "/" contextPropertyPath [ selectList ]
+                / entitySet [ selectList ] [ "/$entity" / "/$delta" ]
+                
+entitySet = entitySetName *( containmentNavigation ) [ "/" qualifiedEntityTypeName ]
+            
+containmentNavigation = keyPredicate [ "/" qualifiedEntityTypeName ] navigation
+navigation            = *( "/" complexProperty [ "/" qualifiedComplexTypeName ] ) "/" navigationProperty   
+
+selectList         = OPEN selectListItem *( COMMA selectListItem ) CLOSE
+selectListItem     = STAR ; all structural properties
+                   / allOperationsInSchema 
+                   / [ qualifiedEntityTypeName "/" ] 
+                     ( qualifiedActionName
+                     / qualifiedFunctionName 
+                     / selectListProperty
+                     )
+selectListProperty = primitiveProperty  
+                   / primitiveColProperty 
+                   / navigationProperty [ "+" ] [ selectList ]
+                   / selectPath [ "/" selectListProperty ]
+
+contextPropertyPath = primitiveProperty
+                    / primitiveColProperty
+                    / complexColProperty
+                    / complexProperty [ [ "/" qualifiedComplexTypeName ] "/" contextPropertyPath ]
+                 
+
+;------------------------------------------------------------------------------
+; 4. Expressions
+;------------------------------------------------------------------------------
+
+; Note: a boolCommonExpr is also a commonExpr, e.g. sort by Boolean 
+commonExpr = ( primitiveLiteral
+             / arrayOrObject
+             / rootExpr
+             / firstMemberExpr
+             / functionExpr
+             / negateExpr 
+             / methodCallExpr 
+             / parenExpr 
+             / listExpr
+             / castExpr 
+             / isofExpr
+             / notExpr
+             ) 
+             [ addExpr 
+             / subExpr 
+             / mulExpr 
+             / divExpr
+             / divbyExpr 
+             / modExpr
+             ]  
+             [ eqExpr 
+             / neExpr 
+             / ltExpr  
+             / leExpr  
+             / gtExpr 
+             / geExpr 
+             / hasExpr 
+             / inExpr 
+             ]
+             [ andExpr 
+             / orExpr 
+             ] 
+
+boolCommonExpr = commonExpr ; resulting in a Boolean
+
+rootExpr = "$root/" ( entitySetName keyPredicate / singletonEntity ) [ singleNavigationExpr ]
+
+firstMemberExpr = memberExpr
+                / inscopeVariableExpr [ "/" memberExpr ]
+
+memberExpr = [ qualifiedEntityTypeName "/" ]
+             ( propertyPathExpr
+             / boundFunctionExpr 
+             / annotationExpr
+             )
+             
+propertyPathExpr = ( entityColNavigationProperty [ collectionNavigationExpr ] 
+                   / entityNavigationProperty    [ singleNavigationExpr ] 
+                   / complexColProperty          [ complexColPathExpr ]
+                   / complexProperty             [ complexPathExpr ] 
+                   / primitiveColProperty        [ collectionPathExpr ]
+                   / primitiveProperty           [ primitivePathExpr ]
+                   / streamProperty              [ primitivePathExpr ]
+                   )
+                   
+annotationExpr = annotation
+                 [ collectionPathExpr
+                 / singleNavigationExpr
+                 / complexPathExpr
+                 / primitivePathExpr
+                 ]
+                 
+annotation          = AT [ namespace "." ] termName [ "#" annotationQualifier ]
+annotationQualifier = odataIdentifier                
+                   
+inscopeVariableExpr  = implicitVariableExpr 
+                     / parameterAlias
+                     / lambdaVariableExpr ; only allowed inside a lambdaPredicateExpr
+implicitVariableExpr = "$it"              ; the current instance of the resource identified by the resource path
+                     / "$this"            ; the instance on which the query option is evaluated
+lambdaVariableExpr   = odataIdentifier
+
+collectionNavigationExpr = [ "/" qualifiedEntityTypeName ]
+                           [ keyPredicate [ singleNavigationExpr ] 
+                           / collectionPathExpr 
+                           ]
+
+singleNavigationExpr = "/" memberExpr
+
+complexColPathExpr = [ "/" qualifiedComplexTypeName ]
+                     [ collectionPathExpr ]
+ 
+collectionPathExpr = count [ OPEN expandCountOption *( SEMI expandCountOption ) CLOSE ]
+                   / "/" boundFunctionExpr
+                   / "/" annotationExpr
+                   / "/" anyExpr
+                   / "/" allExpr
+ 
+complexPathExpr = [ "/" qualifiedComplexTypeName ]
+                  [ "/" propertyPathExpr 
+                  / "/" boundFunctionExpr 
+                  / "/" annotationExpr
+                  ]
+
+primitivePathExpr = "/" [ annotationExpr / boundFunctionExpr ]
+
+boundFunctionExpr = functionExpr ; boundFunction segments can only be composed if the type of the    
+                                 ; previous segment matches the type of the first function parameter
+                                     
+functionExpr = namespace "."
+               ( entityColFunction    functionExprParameters [ collectionNavigationExpr ] 
+               / entityFunction       functionExprParameters [ singleNavigationExpr ] 
+               / complexColFunction   functionExprParameters [ complexColPathExpr ]
+               / complexFunction      functionExprParameters [ complexPathExpr ] 
+               / primitiveColFunction functionExprParameters [ collectionPathExpr ] 
+               / primitiveFunction    functionExprParameters [ primitivePathExpr ] 
+               )
+
+functionExprParameters = OPEN [ functionExprParameter *( COMMA functionExprParameter ) ] CLOSE
+functionExprParameter  = parameterName EQ ( parameterAlias / parameterValue )
+
+anyExpr = "any" OPEN BWS [ lambdaVariableExpr BWS COLON BWS lambdaPredicateExpr ] BWS CLOSE
+allExpr = "all" OPEN BWS   lambdaVariableExpr BWS COLON BWS lambdaPredicateExpr   BWS CLOSE
+lambdaPredicateExpr = boolCommonExpr ; containing at least one lambdaVariableExpr
+
+methodCallExpr = indexOfMethodCallExpr 
+               / toLowerMethodCallExpr 
+               / toUpperMethodCallExpr  
+               / trimMethodCallExpr 
+               / substringMethodCallExpr 
+               / concatMethodCallExpr 
+               / lengthMethodCallExpr 
+               / yearMethodCallExpr 
+               / monthMethodCallExpr 
+               / dayMethodCallExpr 
+               / hourMethodCallExpr 
+               / minuteMethodCallExpr 
+               / secondMethodCallExpr 
+               / fractionalsecondsMethodCallExpr
+               / totalsecondsMethodCallExpr
+               / dateMethodCallExpr 
+               / timeMethodCallExpr 
+               / roundMethodCallExpr 
+               / floorMethodCallExpr 
+               / ceilingMethodCallExpr 
+               / distanceMethodCallExpr 
+               / geoLengthMethodCallExpr 
+               / totalOffsetMinutesMethodCallExpr
+               / minDateTimeMethodCallExpr
+               / maxDateTimeMethodCallExpr
+               / nowMethodCallExpr
+               / boolMethodCallExpr
+
+boolMethodCallExpr = endsWithMethodCallExpr 
+                   / startsWithMethodCallExpr 
+                   / containsMethodCallExpr                                          
+                   / intersectsMethodCallExpr 
+                   / hasSubsetMethodCallExpr
+                   / hasSubsequenceMethodCallExpr
+
+concatMethodCallExpr     = "concat"     OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+containsMethodCallExpr   = "contains"   OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+endsWithMethodCallExpr   = "endswith"   OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+indexOfMethodCallExpr    = "indexof"    OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+lengthMethodCallExpr     = "length"     OPEN BWS commonExpr BWS CLOSE
+startsWithMethodCallExpr = "startswith" OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+substringMethodCallExpr  = "substring"  OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS [ COMMA BWS commonExpr BWS ] CLOSE
+toLowerMethodCallExpr    = "tolower"    OPEN BWS commonExpr BWS CLOSE
+toUpperMethodCallExpr    = "toupper"    OPEN BWS commonExpr BWS CLOSE
+trimMethodCallExpr       = "trim"       OPEN BWS commonExpr BWS CLOSE
+
+yearMethodCallExpr               = "year"               OPEN BWS commonExpr BWS CLOSE
+monthMethodCallExpr              = "month"              OPEN BWS commonExpr BWS CLOSE
+dayMethodCallExpr                = "day"                OPEN BWS commonExpr BWS CLOSE
+hourMethodCallExpr               = "hour"               OPEN BWS commonExpr BWS CLOSE
+minuteMethodCallExpr             = "minute"             OPEN BWS commonExpr BWS CLOSE
+secondMethodCallExpr             = "second"             OPEN BWS commonExpr BWS CLOSE
+fractionalsecondsMethodCallExpr  = "fractionalseconds"  OPEN BWS commonExpr BWS CLOSE
+totalsecondsMethodCallExpr       = "totalseconds"       OPEN BWS commonExpr BWS CLOSE
+dateMethodCallExpr               = "date"               OPEN BWS commonExpr BWS CLOSE
+timeMethodCallExpr               = "time"               OPEN BWS commonExpr BWS CLOSE
+totalOffsetMinutesMethodCallExpr = "totaloffsetminutes" OPEN BWS commonExpr BWS CLOSE 
+
+minDateTimeMethodCallExpr = "mindatetime" OPEN BWS CLOSE
+maxDateTimeMethodCallExpr = "maxdatetime" OPEN BWS CLOSE
+nowMethodCallExpr         = "now"         OPEN BWS CLOSE
+
+roundMethodCallExpr   = "round"   OPEN BWS commonExpr BWS CLOSE
+floorMethodCallExpr   = "floor"   OPEN BWS commonExpr BWS CLOSE
+ceilingMethodCallExpr = "ceiling" OPEN BWS commonExpr BWS CLOSE
+
+distanceMethodCallExpr   = "geo.distance"   OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+geoLengthMethodCallExpr  = "geo.length"     OPEN BWS commonExpr BWS CLOSE
+intersectsMethodCallExpr = "geo.intersects" OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+
+hasSubsetMethodCallExpr      = "hassubset"      OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+hasSubsequenceMethodCallExpr = "hassubsequence" OPEN BWS commonExpr BWS COMMA BWS commonExpr BWS CLOSE
+
+parenExpr = OPEN BWS commonExpr BWS CLOSE
+listExpr  = OPEN BWS commonExpr BWS *( COMMA BWS commonExpr BWS ) CLOSE
+
+andExpr = RWS "and" RWS boolCommonExpr
+orExpr  = RWS "or"  RWS boolCommonExpr
+
+eqExpr = RWS "eq" RWS commonExpr     
+neExpr = RWS "ne" RWS commonExpr
+ltExpr = RWS "lt" RWS commonExpr
+leExpr = RWS "le" RWS commonExpr
+gtExpr = RWS "gt" RWS commonExpr
+geExpr = RWS "ge" RWS commonExpr
+inExpr = RWS "in" RWS commonExpr
+
+hasExpr = RWS "has" RWS enum
+
+addExpr   = RWS "add"   RWS commonExpr
+subExpr   = RWS "sub"   RWS commonExpr
+mulExpr   = RWS "mul"   RWS commonExpr
+divExpr   = RWS "div"   RWS commonExpr
+divbyExpr = RWS "divby" RWS commonExpr
+modExpr   = RWS "mod"   RWS commonExpr
+
+negateExpr = "-" BWS commonExpr
+
+notExpr = "not" RWS boolCommonExpr
+
+isofExpr = "isof" OPEN BWS [ commonExpr BWS COMMA BWS ] qualifiedTypeName BWS CLOSE
+castExpr = "cast" OPEN BWS [ commonExpr BWS COMMA BWS ] qualifiedTypeName BWS CLOSE
+
+
+;------------------------------------------------------------------------------
+; 5. JSON format for function parameters
+;------------------------------------------------------------------------------
+; Note: the query part of a URI needs to be partially percent-decoded before
+; applying these rules, see comment at the top of this file
+;------------------------------------------------------------------------------
+
+arrayOrObject = complexColInUri  
+              / complexInUri
+              / rootExprCol
+              / primitiveColInUri
+               
+complexColInUri = begin-array 
+                  [ complexInUri *( value-separator complexInUri ) ] 
+                  end-array
+                  
+complexInUri = begin-object
+               [ ( annotationInUri 
+                 / primitivePropertyInUri 
+                 / complexPropertyInUri 
+                 / collectionPropertyInUri  
+                 / navigationPropertyInUri
+                 )
+                 *( value-separator 
+                    ( annotationInUri 
+                    / primitivePropertyInUri 
+                    / complexPropertyInUri 
+                    / collectionPropertyInUri  
+                    / navigationPropertyInUri
+                    ) 
+                  )
+               ]  
+               end-object
+
+collectionPropertyInUri = ( quotation-mark primitiveColProperty quotation-mark 
+                            name-separator 
+                            primitiveColInUri 
+                          ) 
+                        / ( quotation-mark complexColProperty quotation-mark 
+                            name-separator 
+                            complexColInUri
+                          )
+
+primitiveColInUri = begin-array 
+                    [ primitiveLiteralInJSON *( value-separator primitiveLiteralInJSON ) ] 
+                    end-array
+                    
+complexPropertyInUri = quotation-mark complexProperty quotation-mark 
+                       name-separator 
+                       complexInUri
+                            
+annotationInUri = quotation-mark AT namespace "." termName quotation-mark
+                  name-separator
+                  ( complexInUri / complexColInUri / primitiveLiteralInJSON / primitiveColInUri )
+
+primitivePropertyInUri = quotation-mark primitiveProperty quotation-mark 
+                         name-separator 
+                         primitiveLiteralInJSON
+
+navigationPropertyInUri = singleNavPropInJSON
+                        / collectionNavPropInJSON
+singleNavPropInJSON     = quotation-mark entityNavigationProperty quotation-mark
+													name-separator
+													rootExpr
+collectionNavPropInJSON = quotation-mark entityColNavigationProperty quotation-mark
+													name-separator
+													rootExprCol
+
+rootExprCol = begin-array 
+              [ rootExpr *( value-separator rootExpr ) ]
+              end-array
+                                        
+; JSON syntax: adapted to URI restrictions from [RFC4627]                 
+begin-object = BWS ( "{" / "%7B" ) BWS
+end-object   = BWS ( "}" / "%7D" )
+
+begin-array = BWS ( "[" / "%5B" ) BWS 
+end-array   = BWS ( "]" / "%5D" )
+
+quotation-mark  = DQUOTE / "%22"
+name-separator  = BWS COLON BWS
+value-separator = BWS COMMA BWS
+
+primitiveLiteralInJSON = stringInJSON
+                       / numberInJSON
+                       / "true" 
+                       / "false"
+                       / "null"
+
+stringInJSON = quotation-mark *charInJSON quotation-mark
+charInJSON   = qchar-unescaped  
+             / qchar-JSON-special    
+             / escape ( quotation-mark 
+                      / escape
+                      / ( "/" / "%2F" ) ; solidus         U+002F - literal form is allowed in the query part of a URL
+                      / "b"             ; backspace       U+0008                
+                      / "f"             ; form feed       U+000C
+                      / "n"             ; line feed       U+000A
+                      / "r"             ; carriage return U+000D
+                      / "t"             ; tab             U+0009
+                      / "u" 4HEXDIG     ;                 U+XXXX
+                      )
+
+qchar-JSON-special = SP / ":" / "{" / "}" / "[" / "]" ; some agents put these unencoded into the query part of a URL
+
+escape = "\" / "%5C"     ; reverse solidus U+005C
+
+numberInJSON = [ "-" ] int [ frac ] [ exp ]
+int          = "0" / ( oneToNine *DIGIT )
+frac         = "." 1*DIGIT
+exp          = "e" [ "-" / "+" ] 1*DIGIT
+
+
+;------------------------------------------------------------------------------
+; 6. Names and identifiers
+;------------------------------------------------------------------------------
+
+singleQualifiedTypeName = qualifiedEntityTypeName 
+                        / qualifiedComplexTypeName
+                        / qualifiedTypeDefinitionName
+                        / qualifiedEnumTypeName
+                        / primitiveTypeName 
+                  
+qualifiedTypeName = singleQualifiedTypeName                  
+                  / "Collection" OPEN singleQualifiedTypeName CLOSE
+
+qualifiedEntityTypeName     = namespace "." entityTypeName
+qualifiedComplexTypeName    = namespace "." complexTypeName
+qualifiedTypeDefinitionName = namespace "." typeDefinitionName 
+qualifiedEnumTypeName       = namespace "." enumerationTypeName
+
+; an alias is just a single-part namespace
+namespace     = namespacePart *( "." namespacePart )
+namespacePart = odataIdentifier
+
+entitySetName       = odataIdentifier
+singletonEntity     = odataIdentifier          
+entityTypeName      = odataIdentifier
+complexTypeName     = odataIdentifier
+typeDefinitionName  = odataIdentifier 
+enumerationTypeName = odataIdentifier
+enumerationMember   = odataIdentifier
+termName            = odataIdentifier
+
+; Note: this pattern is overly restrictive, the normative definition is type TSimpleIdentifier in OData EDM XML Schema
+odataIdentifier             = identifierLeadingCharacter *127identifierCharacter
+identifierLeadingCharacter  = ALPHA / "_"         ; plus Unicode characters from the categories L or Nl
+identifierCharacter         = ALPHA / "_" / DIGIT ; plus Unicode characters from the categories L, Nl, Nd, Mn, Mc, Pc, or Cf
+
+primitiveTypeName = "Edm." ( "Binary"
+                           / "Boolean"
+                           / "Byte"
+                           / "Date" 
+                           / "DateTimeOffset"
+                           / "Decimal"
+                           / "Double"
+                           / "Duration" 
+                           / "Guid" 
+                           / "Int16"
+                           / "Int32"
+                           / "Int64"
+                           / "SByte"
+                           / "Single"
+                           / "Stream"
+                           / "String"
+                           / "TimeOfDay"
+                           / abstractSpatialTypeName [ concreteSpatialTypeName ] 
+                           )
+abstractSpatialTypeName = "Geography"
+                        / "Geometry"
+concreteSpatialTypeName = "Collection"
+                        / "LineString"
+                        / "MultiLineString"
+                        / "MultiPoint"
+                        / "MultiPolygon"
+                        / "Point"
+                        / "Polygon"
+
+primitiveProperty       = primitiveKeyProperty / primitiveNonKeyProperty
+primitiveKeyProperty    = odataIdentifier
+primitiveNonKeyProperty = odataIdentifier
+primitiveColProperty    = odataIdentifier
+complexProperty         = odataIdentifier
+complexColProperty      = odataIdentifier
+streamProperty          = odataIdentifier
+
+navigationProperty          = entityNavigationProperty / entityColNavigationProperty  
+entityNavigationProperty    = odataIdentifier
+entityColNavigationProperty = odataIdentifier
+
+action       = odataIdentifier
+actionImport = odataIdentifier
+
+function = entityFunction 
+         / entityColFunction 
+         / complexFunction 
+         / complexColFunction 
+         / primitiveFunction 
+         / primitiveColFunction
+         
+entityFunction       = odataIdentifier
+entityColFunction    = odataIdentifier
+complexFunction      = odataIdentifier
+complexColFunction   = odataIdentifier
+primitiveFunction    = odataIdentifier
+primitiveColFunction = odataIdentifier
+
+entityFunctionImport       = odataIdentifier
+entityColFunctionImport    = odataIdentifier
+complexFunctionImport      = odataIdentifier
+complexColFunctionImport   = odataIdentifier
+primitiveFunctionImport    = odataIdentifier
+primitiveColFunctionImport = odataIdentifier
+
+
+;------------------------------------------------------------------------------
+; 7. Literal Data Values
+;------------------------------------------------------------------------------
+
+; in URLs
+primitiveLiteral = nullValue                  ; plain values up to int64Value
+                 / booleanValue 
+                 / guidValue 
+                 / dateValue
+                 / dateTimeOffsetValue 
+                 / timeOfDayValue
+                 / decimalValue 
+                 / doubleValue 
+                 / singleValue 
+                 / sbyteValue 
+                 / byteValue
+                 / int16Value 
+                 / int32Value 
+                 / int64Value 
+                 / string                     ; single-quoted
+                 / duration
+                 / enum
+                 / binary                     ; all others are quoted and prefixed 
+                 / geographyCollection 
+                 / geographyLineString 
+                 / geographyMultiLineString 
+                 / geographyMultiPoint 
+                 / geographyMultiPolygon 
+                 / geographyPoint 
+                 / geographyPolygon 
+                 / geometryCollection 
+                 / geometryLineString 
+                 / geometryMultiLineString 
+                 / geometryMultiPoint 
+                 / geometryMultiPolygon 
+                 / geometryPoint 
+                 / geometryPolygon
+         
+; in Atom and JSON message bodies and CSDL DefaultValue attributes                 
+primitiveValue = booleanValue
+               / guidValue
+               / durationValue
+               / dateValue
+               / dateTimeOffsetValue 
+               / timeOfDayValue
+               / enumValue
+               / fullCollectionLiteral
+               / fullLineStringLiteral
+               / fullMultiPointLiteral
+               / fullMultiLineStringLiteral
+               / fullMultiPolygonLiteral
+               / fullPointLiteral
+               / fullPolygonLiteral
+               / decimalValue 
+               / doubleValue 
+               / singleValue 
+               / sbyteValue 
+               / byteValue
+               / int16Value 
+               / int32Value 
+               / int64Value 
+               / binaryValue 
+               ; also valid are:
+               ; - any XML string for strings in Atom and CSDL documents
+               ; - any JSON string for JSON documents 
+
+nullValue = "null" 
+
+; base64url encoding according to http://tools.ietf.org/html/rfc4648#section-5                                             
+binary      = "binary" SQUOTE binaryValue SQUOTE
+binaryValue = *(4base64char) [ base64b16  / base64b8 ]
+base64b16   = 2base64char ( "A" / "E" / "I" / "M" / "Q" / "U" / "Y" / "c" / "g" / "k" / "o" / "s" / "w" / "0" / "4" / "8" )   [ "=" ]
+base64b8    = base64char ( "A" / "Q" / "g" / "w" ) [ "==" ]
+base64char  = ALPHA / DIGIT / "-" / "_"
+
+booleanValue = "true" / "false"
+
+decimalValue = [ SIGN ] 1*DIGIT [ "." 1*DIGIT ] [ "e" [ SIGN ] 1*DIGIT ] / nanInfinity
+doubleValue  = decimalValue ; IEEE 754 binary64 floating-point number (15-17 decimal digits)
+singleValue  = decimalValue ; IEEE 754 binary32 floating-point number (6-9 decimal digits)
+nanInfinity  = "NaN" / "-INF" / "INF"
+
+guidValue = 8HEXDIG "-" 4HEXDIG "-" 4HEXDIG "-" 4HEXDIG "-" 12HEXDIG 
+
+byteValue  = 1*3DIGIT           ; numbers in the range from 0 to 255
+sbyteValue = [ SIGN ] 1*3DIGIT  ; numbers in the range from -128 to 127
+int16Value = [ SIGN ] 1*5DIGIT  ; numbers in the range from -32768 to 32767        
+int32Value = [ SIGN ] 1*10DIGIT ; numbers in the range from -2147483648 to 2147483647
+int64Value = [ SIGN ] 1*19DIGIT ; numbers in the range from -9223372036854775808 to 9223372036854775807
+
+string           = SQUOTE *( SQUOTE-in-string / pchar-no-SQUOTE ) SQUOTE
+SQUOTE-in-string = SQUOTE SQUOTE ; two consecutive single quotes represent one within a string literal
+
+dateValue = year "-" month "-" day
+
+dateTimeOffsetValue = year "-" month "-" day "T" hour ":" minute [ ":" second [ "." fractionalSeconds ] ] ( "Z" / SIGN hour ":" minute )
+
+duration      = [ "duration" ] SQUOTE durationValue SQUOTE
+durationValue = [ SIGN ] "P" [ 1*DIGIT "D" ] [ "T" [ 1*DIGIT "H" ] [ 1*DIGIT "M" ] [ 1*DIGIT [ "." 1*DIGIT ] "S" ] ]
+     ; the above is an approximation of the rules for an xml dayTimeDuration.
+     ; see the lexical representation for dayTimeDuration in http://www.w3.org/TR/xmlschema11-2#dayTimeDuration for more information
+
+timeOfDayValue = hour ":" minute [ ":" second [ "." fractionalSeconds ] ]
+ 
+oneToNine       = "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9" 
+zeroToFiftyNine = ( "0" / "1" / "2" / "3" / "4" / "5" ) DIGIT
+year  = [ "-" ] ( "0" 3DIGIT / oneToNine 3*DIGIT )
+month = "0" oneToNine
+      / "1" ( "0" / "1" / "2" )
+day   = "0" oneToNine
+      / ( "1" / "2" ) DIGIT
+      / "3" ( "0" / "1" )
+hour   = ( "0" / "1" ) DIGIT
+       / "2" ( "0" / "1" / "2" / "3" ) 
+minute = zeroToFiftyNine
+second = zeroToFiftyNine       
+fractionalSeconds = 1*12DIGIT
+
+enum            = [ qualifiedEnumTypeName ] SQUOTE enumValue SQUOTE
+enumValue       = singleEnumValue *( COMMA singleEnumValue )
+singleEnumValue = enumerationMember / enumMemberValue
+enumMemberValue = int64Value
+
+geographyCollection   = geographyPrefix SQUOTE fullCollectionLiteral SQUOTE
+fullCollectionLiteral = sridLiteral collectionLiteral
+collectionLiteral     = "Collection(" geoLiteral *( COMMA geoLiteral ) CLOSE
+geoLiteral            = collectionLiteral
+                      / lineStringLiteral
+                      / multiPointLiteral
+                      / multiLineStringLiteral
+                      / multiPolygonLiteral
+                      / pointLiteral
+                      / polygonLiteral
+
+geographyLineString   = geographyPrefix SQUOTE fullLineStringLiteral SQUOTE
+fullLineStringLiteral = sridLiteral lineStringLiteral
+lineStringLiteral     = "LineString" lineStringData
+lineStringData        = OPEN positionLiteral 1*( COMMA positionLiteral ) CLOSE
+
+geographyMultiLineString   = geographyPrefix SQUOTE fullMultiLineStringLiteral SQUOTE
+fullMultiLineStringLiteral = sridLiteral multiLineStringLiteral
+multiLineStringLiteral     = "MultiLineString(" [ lineStringData *( COMMA lineStringData ) ] CLOSE
+
+geographyMultiPoint   = geographyPrefix SQUOTE fullMultiPointLiteral SQUOTE
+fullMultiPointLiteral = sridLiteral multiPointLiteral
+multiPointLiteral     = "MultiPoint(" [ pointData *( COMMA pointData ) ] CLOSE
+
+geographyMultiPolygon   = geographyPrefix SQUOTE fullMultiPolygonLiteral SQUOTE
+fullMultiPolygonLiteral = sridLiteral multiPolygonLiteral
+multiPolygonLiteral     = "MultiPolygon(" [ polygonData *( COMMA polygonData ) ] CLOSE
+
+geographyPoint   = geographyPrefix SQUOTE fullPointLiteral SQUOTE
+fullPointLiteral = sridLiteral pointLiteral
+sridLiteral      = "SRID" EQ 1*5DIGIT SEMI
+pointLiteral     ="Point" pointData
+pointData        = OPEN positionLiteral CLOSE
+positionLiteral  = doubleValue SP doubleValue  ; longitude, then latitude
+
+geographyPolygon   = geographyPrefix SQUOTE fullPolygonLiteral SQUOTE
+fullPolygonLiteral = sridLiteral polygonLiteral
+polygonLiteral     = "Polygon" polygonData
+polygonData        = OPEN ringLiteral *( COMMA ringLiteral ) CLOSE
+ringLiteral        = OPEN positionLiteral *( COMMA positionLiteral ) CLOSE
+                   ; Within each ringLiteral, the first and last positionLiteral elements MUST be an exact syntactic match to each other.
+                   ; Within the polygonData, the ringLiterals MUST specify their points in appropriate winding order. 
+                   ; In order of traversal, points to the left side of the ring are interpreted as being in the polygon.
+
+geometryCollection      = geometryPrefix SQUOTE fullCollectionLiteral      SQUOTE
+geometryLineString      = geometryPrefix SQUOTE fullLineStringLiteral      SQUOTE
+geometryMultiLineString = geometryPrefix SQUOTE fullMultiLineStringLiteral SQUOTE
+geometryMultiPoint      = geometryPrefix SQUOTE fullMultiPointLiteral      SQUOTE
+geometryMultiPolygon    = geometryPrefix SQUOTE fullMultiPolygonLiteral    SQUOTE
+geometryPoint           = geometryPrefix SQUOTE fullPointLiteral           SQUOTE
+geometryPolygon         = geometryPrefix SQUOTE fullPolygonLiteral         SQUOTE
+
+geographyPrefix = "geography"
+geometryPrefix  = "geometry" 
+
+
+;------------------------------------------------------------------------------
+; 8. Header values
+;------------------------------------------------------------------------------
+
+header = content-id
+       / entityid 
+       / isolation
+       / odata-maxversion
+       / odata-version
+       / prefer
+
+content-id = "Content-ID" ":" OWS request-id
+request-id = 1*unreserved
+       
+entityid   = [ "OData-" ] "EntityID" ":" OWS IRI-in-header
+isolation  = [ "OData-" ] "Isolation" ":" OWS "snapshot"
+odata-maxversion = "OData-MaxVersion" ":" OWS 1*DIGIT "." 1*DIGIT     
+odata-version    = "OData-Version"    ":" OWS "4.0" [ oneToNine ]
+      
+prefer     = "Prefer" ":" OWS preference *( COMMA preference )       
+preference = allowEntityReferencesPreference
+           / callbackPreference
+           / continueOnErrorPreference
+           / includeAnnotationsPreference
+           / maxpagesizePreference
+           / respondAsyncPreference
+           / returnPreference
+           / trackChangesPreference
+           / waitPreference
+           ; and everything allowed by http://tools.ietf.org/html/draft-snell-http-prefer-18
+           ; / token [ EQ-h word ] *( OWS ";" [ OWS parameter ] )
+           
+allowEntityReferencesPreference = [ "odata." ] "allow-entityreferences"
+
+callbackPreference = [ "odata." ] "callback" OWS ";" OWS "url" EQ-h DQUOTE URI DQUOTE
+
+continueOnErrorPreference = [ "odata." ] "continue-on-error" [ EQ-h booleanValue ]   
+           
+includeAnnotationsPreference = [ "odata." ] "include-annotations" EQ-h DQUOTE annotationsList DQUOTE
+annotationsList      = annotationIdentifier *(COMMA annotationIdentifier)
+annotationIdentifier = [ excludeOperator ]
+                       ( STAR 
+                       / namespace "." ( termName / STAR ) 
+                       ) 
+                       [ "#" odataIdentifier ]
+excludeOperator      = "-"
+           
+maxpagesizePreference = [ "odata." ] "maxpagesize" EQ-h oneToNine *DIGIT         
+
+respondAsyncPreference = "respond-async"
+
+returnPreference = "return" EQ-h ( "representation" / "minimal" )
+
+trackChangesPreference = [ "odata." ] "track-changes"
+
+waitPreference = "wait" EQ-h 1*DIGIT
+
+;parameter      = token [ EQ-h word ]
+;word           = token / quoted-string
+;token          = 1*tchar
+;tchar          = "!" / "#" / "$" / "%" / "&" / """ / "*"
+;               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+;               / DIGIT / ALPHA
+;quoted-string  = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+;qdtext         = %x21 / %x23-5B / %x5D-7E / obs-text / OWS
+obs-text       = %x80-FF
+;quoted-pair    = "\" ( HTAB / SP / VCHAR / obs-text )
+
+OWS   = *( SP / HTAB )  ; "optional" whitespace 
+BWS-h = *( SP / HTAB )  ; "bad" whitespace in header values 
+EQ-h  = BWS-h EQ BWS-h 
+
+
+;------------------------------------------------------------------------------
+; 9. Punctuation
+;------------------------------------------------------------------------------
+
+RWS = 1*( SP / HTAB / "%20" / "%09" )  ; "required" whitespace 
+BWS =  *( SP / HTAB / "%20" / "%09" )  ; "bad" whitespace 
+
+AT     = "@" / "%40"
+COLON  = ":" / "%3A"
+COMMA  = "," / "%2C"
+EQ     = "="
+SIGN   = "+" / "%2B" / "-"
+SEMI   = ";" / "%3B"
+STAR   = "*" / "%2A"
+SQUOTE = "'" / "%27"
+
+OPEN  = "(" / "%28"
+CLOSE = ")" / "%29"
+
+
+;------------------------------------------------------------------------------
+; A. URI syntax [RFC3986]
+;------------------------------------------------------------------------------
+
+URI           = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+hier-part     = "//" authority path-abempty
+              / path-absolute
+              / path-rootless
+;              / path-empty
+;URI-reference = URI / relative-ref
+;absolute-URI  = scheme ":" hier-part [ "?" query ]
+;relative-ref  = relative-part [ "?" query ] [ "#" fragment ]
+;relative-part = "//" authority path-abempty
+;              / path-absolute
+;              / path-noscheme
+;              / path-empty
+scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+authority     = [ userinfo "@" ] host [ ":" port ]
+userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
+host          = IP-literal / IPv4address / reg-name
+port          = *DIGIT
+IP-literal    = "[" ( IPv6address / IPvFuture  ) "]"
+IPvFuture     = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
+IPv6address   =                            6( h16 ":" ) ls32
+                 /                       "::" 5( h16 ":" ) ls32
+                 / [               h16 ] "::" 4( h16 ":" ) ls32
+                 / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+                 / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+                 / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+                 / [ *4( h16 ":" ) h16 ] "::"              ls32
+                 / [ *5( h16 ":" ) h16 ] "::"              h16
+                 / [ *6( h16 ":" ) h16 ] "::"
+h16           = 1*4HEXDIG
+ls32          = ( h16 ":" h16 ) / IPv4address
+IPv4address   = dec-octet "." dec-octet "." dec-octet "." dec-octet
+dec-octet     = "1" 2DIGIT            ; 100-199
+              / "2" %x30-34 DIGIT     ; 200-249
+              / "25" %x30-35          ; 250-255
+              / %x31-39 DIGIT         ; 10-99
+              / DIGIT                 ; 0-9
+reg-name      = *( unreserved / pct-encoded / sub-delims )
+;path          = path-abempty    ; begins with "/" or is empty
+;              / path-absolute   ; begins with "/" but not "//"
+;              / path-noscheme   ; begins with a non-colon segment
+;              / path-rootless   ; begins with a segment
+;              / path-empty      ; zero characters
+path-abempty  = *( "/" segment )
+path-absolute = "/" [ segment-nz *( "/" segment ) ]
+;path-noscheme = segment-nz-nc *( "/" segment )
+path-rootless = segment-nz *( "/" segment )
+;path-empty    = ""
+segment       = *pchar
+segment-nz    = 1*pchar
+;segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" ) ; non-zero-length segment without any colon ":"
+pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+query         = *( pchar / "/" / "?" )
+fragment      = *( pchar / "/" / "?" )
+pct-encoded   = "%" HEXDIG HEXDIG
+unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+;reserved      = gen-delims / sub-delims
+;gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+;sub-delims    = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+sub-delims     =       "$" / "&" / "'" /                                     "=" / other-delims
+other-delims   = "!" /                   "(" / ")" / "*" / "+" / "," / ";"
+
+pchar-no-SQUOTE       = unreserved / pct-encoded-no-SQUOTE / other-delims / "$" / "&" / "=" / ":" / "@"
+pct-encoded-no-SQUOTE = "%" ( "0" / "1" /   "3" / "4" / "5" / "6" / "8" / "9" / A-to-F ) HEXDIG 
+                      / "%" "2" ( "0" / "1" / "2" / "3" / "4" / "5" / "6" /   "8" / "9" / A-to-F )
+
+qchar-no-AMP              = unreserved / pct-encoded / other-delims / ":" / "@" / "/" / "?" / "$" / "'" / "="
+qchar-no-AMP-EQ           = unreserved / pct-encoded / other-delims / ":" / "@" / "/" / "?" / "$" / "'"
+qchar-no-AMP-EQ-AT-DOLLAR = unreserved / pct-encoded / other-delims / ":" /       "/" / "?" /       "'"
+
+qchar-unescaped       = unreserved / pct-encoded-unescaped / other-delims / ":" / "@" / "/" / "?" / "$" / "'" / "="
+pct-encoded-unescaped = "%" ( "0" / "1" /   "3" / "4" /   "6" / "7" / "8" / "9" / A-to-F ) HEXDIG 
+                      / "%" "2" ( "0" / "1" /   "3" / "4" / "5" / "6" / "7" / "8" / "9" / A-to-F ) 
+                      / "%" "5" ( DIGIT / "A" / "B" /   "D" / "E" / "F" )
+
+qchar-no-AMP-DQUOTE   = qchar-unescaped 
+                      / escape ( escape / quotation-mark )
+                 
+                 
+;------------------------------------------------------------------------------
+; B. IRI syntax [RFC3987]
+;------------------------------------------------------------------------------
+; Note: these are over-generous stubs, for the actual patterns refer to RFC3987
+;------------------------------------------------------------------------------
+
+IRI-in-header = 1*( VCHAR / obs-text )
+IRI-in-query  = 1*qchar-no-AMP
+
+                      
+;------------------------------------------------------------------------------
+; C. ABNF core definitions [RFC5234]
+;------------------------------------------------------------------------------
+
+ALPHA  = %x41-5A / %x61-7A 
+DIGIT  = %x30-39 
+HEXDIG = DIGIT / A-to-F
+A-to-F = "A" / "B" / "C" / "D" / "E" / "F" 
+DQUOTE = %x22
+SP     = %x20 
+HTAB   = %x09 
+;WSP    = SP / HTAB 
+;LWSP = *(WSP / CRLF WSP) 
+VCHAR = %x21-7E 
+;CHAR = %x01-7F
+;LOCTET = %x00-FF 
+;CR     = %x0D 
+;LF     = %x0A 
+;CRLF   = CR LF
+;BIT = "0" / "1" 
+
+
+;------------------------------------------------------------------------------
+; End of odata-abnf-construction-rules
+;------------------------------------------------------------------------------
diff --git a/odata/odata.csproj b/odata/odata.csproj
new file mode 100644
index 0000000000..696bb9aa6b
--- /dev/null
+++ b/odata/odata.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <RootNamespace />
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Sprache" Version="2.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Root\OdataResourcePath\SyntacticCstNodes\" />
+  </ItemGroup>
+
+</Project>