//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 3.5.0.2
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// $ANTLR 3.5.0.2 SqlDdlReader.g 2015-09-12 18:36:37

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 219
// Unreachable code detected.
#pragma warning disable 162
// Missing XML comment for publicly visible type or member 'Type_or_Member'
#pragma warning disable 1591
// CLS compliance checking will not be performed on 'type' because it is not visible from outside this assembly.
#pragma warning disable 3019


using System.Collections.Generic;
using Antlr.Runtime;
using Antlr.Runtime.Misc;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.5.0.2")]
[System.CLSCompliant(false)]
public partial class SqlDdlReaderLexer : Antlr.Runtime.Lexer
{
	public const int EOF=-1;
	public const int ADD=4;
	public const int ALTER=5;
	public const int CLUSTERED=6;
	public const int COMMENT=7;
	public const int CREATE=8;
	public const int FOREIGN=9;
	public const int ID=10;
	public const int IDENTITY=11;
	public const int INT=12;
	public const int KEY=13;
	public const int NOT=14;
	public const int NULL=15;
	public const int PRIMARY=16;
	public const int REFERENCES=17;
	public const int TABLE=18;
	public const int WS=19;
	public const int T__20=20;
	public const int T__21=21;
	public const int T__22=22;
	public const int T__23=23;

	// delegates
	// delegators

	public SqlDdlReaderLexer()
	{
		OnCreated();
	}

	public SqlDdlReaderLexer(ICharStream input )
		: this(input, new RecognizerSharedState())
	{
	}

	public SqlDdlReaderLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state)
	{

		OnCreated();
	}
	public override string GrammarFileName { get { return "SqlDdlReader.g"; } }


	partial void OnCreated();
	partial void EnterRule(string ruleName, int ruleIndex);
	partial void LeaveRule(string ruleName, int ruleIndex);

	partial void EnterRule_T__20();
	partial void LeaveRule_T__20();

	// $ANTLR start "T__20"
	[GrammarRule("T__20")]
	private void mT__20()
	{
		EnterRule_T__20();
		EnterRule("T__20", 1);
		TraceIn("T__20", 1);
		try
		{
			int _type = T__20;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:7:7: ( '(' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:7:9: '('
			{
			DebugLocation(7, 9);
			Match('('); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("T__20", 1);
			LeaveRule("T__20", 1);
			LeaveRule_T__20();
		}
	}
	// $ANTLR end "T__20"

	partial void EnterRule_T__21();
	partial void LeaveRule_T__21();

	// $ANTLR start "T__21"
	[GrammarRule("T__21")]
	private void mT__21()
	{
		EnterRule_T__21();
		EnterRule("T__21", 2);
		TraceIn("T__21", 2);
		try
		{
			int _type = T__21;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:8:7: ( ')' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:8:9: ')'
			{
			DebugLocation(8, 9);
			Match(')'); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("T__21", 2);
			LeaveRule("T__21", 2);
			LeaveRule_T__21();
		}
	}
	// $ANTLR end "T__21"

	partial void EnterRule_T__22();
	partial void LeaveRule_T__22();

	// $ANTLR start "T__22"
	[GrammarRule("T__22")]
	private void mT__22()
	{
		EnterRule_T__22();
		EnterRule("T__22", 3);
		TraceIn("T__22", 3);
		try
		{
			int _type = T__22;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:9:7: ( ',' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:9:9: ','
			{
			DebugLocation(9, 9);
			Match(','); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("T__22", 3);
			LeaveRule("T__22", 3);
			LeaveRule_T__22();
		}
	}
	// $ANTLR end "T__22"

	partial void EnterRule_T__23();
	partial void LeaveRule_T__23();

	// $ANTLR start "T__23"
	[GrammarRule("T__23")]
	private void mT__23()
	{
		EnterRule_T__23();
		EnterRule("T__23", 4);
		TraceIn("T__23", 4);
		try
		{
			int _type = T__23;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:10:7: ( ';' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:10:9: ';'
			{
			DebugLocation(10, 9);
			Match(';'); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("T__23", 4);
			LeaveRule("T__23", 4);
			LeaveRule_T__23();
		}
	}
	// $ANTLR end "T__23"

	partial void EnterRule_CREATE();
	partial void LeaveRule_CREATE();

	// $ANTLR start "CREATE"
	[GrammarRule("CREATE")]
	private void mCREATE()
	{
		EnterRule_CREATE();
		EnterRule("CREATE", 5);
		TraceIn("CREATE", 5);
		try
		{
			int _type = CREATE;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:95:9: ( ( 'c' | 'C' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'a' | 'A' ) ( 't' | 'T' ) ( 'e' | 'E' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:95:11: ( 'c' | 'C' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'a' | 'A' ) ( 't' | 'T' ) ( 'e' | 'E' )
			{
			DebugLocation(95, 11);
			if (input.LA(1)=='C'||input.LA(1)=='c')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(95, 20);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(95, 29);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(95, 38);
			if (input.LA(1)=='A'||input.LA(1)=='a')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(95, 47);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(95, 56);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("CREATE", 5);
			LeaveRule("CREATE", 5);
			LeaveRule_CREATE();
		}
	}
	// $ANTLR end "CREATE"

	partial void EnterRule_TABLE();
	partial void LeaveRule_TABLE();

	// $ANTLR start "TABLE"
	[GrammarRule("TABLE")]
	private void mTABLE()
	{
		EnterRule_TABLE();
		EnterRule("TABLE", 6);
		TraceIn("TABLE", 6);
		try
		{
			int _type = TABLE;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:97:8: ( ( 't' | 'T' ) ( 'a' | 'A' ) ( 'b' | 'B' ) ( 'l' | 'L' ) ( 'e' | 'E' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:97:10: ( 't' | 'T' ) ( 'a' | 'A' ) ( 'b' | 'B' ) ( 'l' | 'L' ) ( 'e' | 'E' )
			{
			DebugLocation(97, 10);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(97, 19);
			if (input.LA(1)=='A'||input.LA(1)=='a')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(97, 28);
			if (input.LA(1)=='B'||input.LA(1)=='b')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(97, 37);
			if (input.LA(1)=='L'||input.LA(1)=='l')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(97, 46);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("TABLE", 6);
			LeaveRule("TABLE", 6);
			LeaveRule_TABLE();
		}
	}
	// $ANTLR end "TABLE"

	partial void EnterRule_NOT();
	partial void LeaveRule_NOT();

	// $ANTLR start "NOT"
	[GrammarRule("NOT")]
	private void mNOT()
	{
		EnterRule_NOT();
		EnterRule("NOT", 7);
		TraceIn("NOT", 7);
		try
		{
			int _type = NOT;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:99:6: ( ( 'n' | 'N' ) ( 'o' | 'O' ) ( 't' | 'T' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:99:8: ( 'n' | 'N' ) ( 'o' | 'O' ) ( 't' | 'T' )
			{
			DebugLocation(99, 8);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(99, 17);
			if (input.LA(1)=='O'||input.LA(1)=='o')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(99, 26);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("NOT", 7);
			LeaveRule("NOT", 7);
			LeaveRule_NOT();
		}
	}
	// $ANTLR end "NOT"

	partial void EnterRule_NULL();
	partial void LeaveRule_NULL();

	// $ANTLR start "NULL"
	[GrammarRule("NULL")]
	private void mNULL()
	{
		EnterRule_NULL();
		EnterRule("NULL", 8);
		TraceIn("NULL", 8);
		try
		{
			int _type = NULL;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:101:7: ( ( 'n' | 'N' ) ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:101:9: ( 'n' | 'N' ) ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' )
			{
			DebugLocation(101, 9);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(101, 18);
			if (input.LA(1)=='U'||input.LA(1)=='u')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(101, 27);
			if (input.LA(1)=='L'||input.LA(1)=='l')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(101, 36);
			if (input.LA(1)=='L'||input.LA(1)=='l')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("NULL", 8);
			LeaveRule("NULL", 8);
			LeaveRule_NULL();
		}
	}
	// $ANTLR end "NULL"

	partial void EnterRule_IDENTITY();
	partial void LeaveRule_IDENTITY();

	// $ANTLR start "IDENTITY"
	[GrammarRule("IDENTITY")]
	private void mIDENTITY()
	{
		EnterRule_IDENTITY();
		EnterRule("IDENTITY", 9);
		TraceIn("IDENTITY", 9);
		try
		{
			int _type = IDENTITY;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:103:10: ( ( 'i' | 'I' ) ( 'd' | 'D' ) ( 'e' | 'E' ) ( 'n' | 'N' ) ( 't' | 'T' ) ( 'i' | 'I' ) ( 't' | 'T' ) ( 'y' | 'Y' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:103:12: ( 'i' | 'I' ) ( 'd' | 'D' ) ( 'e' | 'E' ) ( 'n' | 'N' ) ( 't' | 'T' ) ( 'i' | 'I' ) ( 't' | 'T' ) ( 'y' | 'Y' )
			{
			DebugLocation(103, 12);
			if (input.LA(1)=='I'||input.LA(1)=='i')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 21);
			if (input.LA(1)=='D'||input.LA(1)=='d')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 30);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 39);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 48);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 57);
			if (input.LA(1)=='I'||input.LA(1)=='i')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 66);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(103, 75);
			if (input.LA(1)=='Y'||input.LA(1)=='y')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("IDENTITY", 9);
			LeaveRule("IDENTITY", 9);
			LeaveRule_IDENTITY();
		}
	}
	// $ANTLR end "IDENTITY"

	partial void EnterRule_PRIMARY();
	partial void LeaveRule_PRIMARY();

	// $ANTLR start "PRIMARY"
	[GrammarRule("PRIMARY")]
	private void mPRIMARY()
	{
		EnterRule_PRIMARY();
		EnterRule("PRIMARY", 10);
		TraceIn("PRIMARY", 10);
		try
		{
			int _type = PRIMARY;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:105:9: ( ( 'p' | 'P' ) ( 'r' | 'R' ) ( 'i' | 'I' ) ( 'm' | 'M' ) ( 'a' | 'A' ) ( 'r' | 'R' ) ( 'y' | 'Y' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:105:11: ( 'p' | 'P' ) ( 'r' | 'R' ) ( 'i' | 'I' ) ( 'm' | 'M' ) ( 'a' | 'A' ) ( 'r' | 'R' ) ( 'y' | 'Y' )
			{
			DebugLocation(105, 11);
			if (input.LA(1)=='P'||input.LA(1)=='p')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(105, 20);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(105, 29);
			if (input.LA(1)=='I'||input.LA(1)=='i')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(105, 38);
			if (input.LA(1)=='M'||input.LA(1)=='m')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(105, 47);
			if (input.LA(1)=='A'||input.LA(1)=='a')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(105, 56);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(105, 65);
			if (input.LA(1)=='Y'||input.LA(1)=='y')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("PRIMARY", 10);
			LeaveRule("PRIMARY", 10);
			LeaveRule_PRIMARY();
		}
	}
	// $ANTLR end "PRIMARY"

	partial void EnterRule_KEY();
	partial void LeaveRule_KEY();

	// $ANTLR start "KEY"
	[GrammarRule("KEY")]
	private void mKEY()
	{
		EnterRule_KEY();
		EnterRule("KEY", 11);
		TraceIn("KEY", 11);
		try
		{
			int _type = KEY;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:107:5: ( ( 'k' | 'K' ) ( 'e' | 'E' ) ( 'y' | 'Y' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:107:7: ( 'k' | 'K' ) ( 'e' | 'E' ) ( 'y' | 'Y' )
			{
			DebugLocation(107, 7);
			if (input.LA(1)=='K'||input.LA(1)=='k')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(107, 16);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(107, 25);
			if (input.LA(1)=='Y'||input.LA(1)=='y')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("KEY", 11);
			LeaveRule("KEY", 11);
			LeaveRule_KEY();
		}
	}
	// $ANTLR end "KEY"

	partial void EnterRule_ALTER();
	partial void LeaveRule_ALTER();

	// $ANTLR start "ALTER"
	[GrammarRule("ALTER")]
	private void mALTER()
	{
		EnterRule_ALTER();
		EnterRule("ALTER", 12);
		TraceIn("ALTER", 12);
		try
		{
			int _type = ALTER;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:109:8: ( ( 'a' | 'A' ) ( 'l' | 'L' ) ( 't' | 'T' ) ( 'e' | 'E' ) ( 'r' | 'R' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:109:10: ( 'a' | 'A' ) ( 'l' | 'L' ) ( 't' | 'T' ) ( 'e' | 'E' ) ( 'r' | 'R' )
			{
			DebugLocation(109, 10);
			if (input.LA(1)=='A'||input.LA(1)=='a')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(109, 19);
			if (input.LA(1)=='L'||input.LA(1)=='l')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(109, 28);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(109, 37);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(109, 46);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("ALTER", 12);
			LeaveRule("ALTER", 12);
			LeaveRule_ALTER();
		}
	}
	// $ANTLR end "ALTER"

	partial void EnterRule_ADD();
	partial void LeaveRule_ADD();

	// $ANTLR start "ADD"
	[GrammarRule("ADD")]
	private void mADD()
	{
		EnterRule_ADD();
		EnterRule("ADD", 13);
		TraceIn("ADD", 13);
		try
		{
			int _type = ADD;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:111:6: ( ( 'a' | 'A' ) ( 'd' | 'D' ) ( 'd' | 'D' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:111:8: ( 'a' | 'A' ) ( 'd' | 'D' ) ( 'd' | 'D' )
			{
			DebugLocation(111, 8);
			if (input.LA(1)=='A'||input.LA(1)=='a')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(111, 17);
			if (input.LA(1)=='D'||input.LA(1)=='d')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(111, 26);
			if (input.LA(1)=='D'||input.LA(1)=='d')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("ADD", 13);
			LeaveRule("ADD", 13);
			LeaveRule_ADD();
		}
	}
	// $ANTLR end "ADD"

	partial void EnterRule_FOREIGN();
	partial void LeaveRule_FOREIGN();

	// $ANTLR start "FOREIGN"
	[GrammarRule("FOREIGN")]
	private void mFOREIGN()
	{
		EnterRule_FOREIGN();
		EnterRule("FOREIGN", 14);
		TraceIn("FOREIGN", 14);
		try
		{
			int _type = FOREIGN;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:113:9: ( ( 'f' | 'F' ) ( 'o' | 'O' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'i' | 'I' ) ( 'g' | 'G' ) ( 'n' | 'N' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:113:11: ( 'f' | 'F' ) ( 'o' | 'O' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'i' | 'I' ) ( 'g' | 'G' ) ( 'n' | 'N' )
			{
			DebugLocation(113, 11);
			if (input.LA(1)=='F'||input.LA(1)=='f')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(113, 20);
			if (input.LA(1)=='O'||input.LA(1)=='o')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(113, 29);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(113, 38);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(113, 47);
			if (input.LA(1)=='I'||input.LA(1)=='i')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(113, 56);
			if (input.LA(1)=='G'||input.LA(1)=='g')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(113, 65);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("FOREIGN", 14);
			LeaveRule("FOREIGN", 14);
			LeaveRule_FOREIGN();
		}
	}
	// $ANTLR end "FOREIGN"

	partial void EnterRule_REFERENCES();
	partial void LeaveRule_REFERENCES();

	// $ANTLR start "REFERENCES"
	[GrammarRule("REFERENCES")]
	private void mREFERENCES()
	{
		EnterRule_REFERENCES();
		EnterRule("REFERENCES", 15);
		TraceIn("REFERENCES", 15);
		try
		{
			int _type = REFERENCES;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:115:12: ( ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'f' | 'F' ) ( 'e' | 'E' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'n' | 'N' ) ( 'c' | 'C' ) ( 'e' | 'E' ) ( 's' | 'S' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:115:14: ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'f' | 'F' ) ( 'e' | 'E' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'n' | 'N' ) ( 'c' | 'C' ) ( 'e' | 'E' ) ( 's' | 'S' )
			{
			DebugLocation(115, 14);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 23);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 32);
			if (input.LA(1)=='F'||input.LA(1)=='f')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 41);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 50);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 59);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 68);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 77);
			if (input.LA(1)=='C'||input.LA(1)=='c')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 86);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(115, 95);
			if (input.LA(1)=='S'||input.LA(1)=='s')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("REFERENCES", 15);
			LeaveRule("REFERENCES", 15);
			LeaveRule_REFERENCES();
		}
	}
	// $ANTLR end "REFERENCES"

	partial void EnterRule_CLUSTERED();
	partial void LeaveRule_CLUSTERED();

	// $ANTLR start "CLUSTERED"
	[GrammarRule("CLUSTERED")]
	private void mCLUSTERED()
	{
		EnterRule_CLUSTERED();
		EnterRule("CLUSTERED", 16);
		TraceIn("CLUSTERED", 16);
		try
		{
			int _type = CLUSTERED;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:117:11: ( ( 'c' | 'C' ) ( 'l' | 'L' ) ( 'u' | 'U' ) ( 's' | 'S' ) ( 't' | 'T' ) ( 'e' | 'E' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'd' | 'D' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:117:13: ( 'c' | 'C' ) ( 'l' | 'L' ) ( 'u' | 'U' ) ( 's' | 'S' ) ( 't' | 'T' ) ( 'e' | 'E' ) ( 'r' | 'R' ) ( 'e' | 'E' ) ( 'd' | 'D' )
			{
			DebugLocation(117, 13);
			if (input.LA(1)=='C'||input.LA(1)=='c')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 22);
			if (input.LA(1)=='L'||input.LA(1)=='l')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 31);
			if (input.LA(1)=='U'||input.LA(1)=='u')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 40);
			if (input.LA(1)=='S'||input.LA(1)=='s')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 49);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 58);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 68);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 77);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(117, 86);
			if (input.LA(1)=='D'||input.LA(1)=='d')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("CLUSTERED", 16);
			LeaveRule("CLUSTERED", 16);
			LeaveRule_CLUSTERED();
		}
	}
	// $ANTLR end "CLUSTERED"

	partial void EnterRule_ID();
	partial void LeaveRule_ID();

	// $ANTLR start "ID"
	[GrammarRule("ID")]
	private void mID()
	{
		EnterRule_ID();
		EnterRule("ID", 17);
		TraceIn("ID", 17);
		try
		{
			int _type = ID;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:119:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
			DebugEnterAlt(1);
			// SqlDdlReader.g:119:8: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
			{
			DebugLocation(119, 8);
			if ((input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z'))
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(119, 32);
			// SqlDdlReader.g:119:32: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
			try { DebugEnterSubRule(1);
			while (true)
			{
				int alt1=2;
				try { DebugEnterDecision(1, false);
				int LA1_1 = input.LA(1);

				if (((LA1_1>='0' && LA1_1<='9')||(LA1_1>='A' && LA1_1<='Z')||LA1_1=='_'||(LA1_1>='a' && LA1_1<='z')))
				{
					alt1 = 1;
				}


				} finally { DebugExitDecision(1); }
				switch ( alt1 )
				{
				case 1:
					DebugEnterAlt(1);
					// SqlDdlReader.g:
					{
					DebugLocation(119, 32);
					input.Consume();


					}
					break;

				default:
					goto loop1;
				}
			}

			loop1:
				;

			} finally { DebugExitSubRule(1); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("ID", 17);
			LeaveRule("ID", 17);
			LeaveRule_ID();
		}
	}
	// $ANTLR end "ID"

	partial void EnterRule_INT();
	partial void LeaveRule_INT();

	// $ANTLR start "INT"
	[GrammarRule("INT")]
	private void mINT()
	{
		EnterRule_INT();
		EnterRule("INT", 18);
		TraceIn("INT", 18);
		try
		{
			int _type = INT;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:121:6: ( ( '0' .. '9' )+ )
			DebugEnterAlt(1);
			// SqlDdlReader.g:121:8: ( '0' .. '9' )+
			{
			DebugLocation(121, 11);
			// SqlDdlReader.g:121:11: ( '0' .. '9' )+
			int cnt2=0;
			try { DebugEnterSubRule(2);
			while (true)
			{
				int alt2=2;
				try { DebugEnterDecision(2, false);
				int LA2_1 = input.LA(1);

				if (((LA2_1>='0' && LA2_1<='9')))
				{
					alt2 = 1;
				}


				} finally { DebugExitDecision(2); }
				switch (alt2)
				{
				case 1:
					DebugEnterAlt(1);
					// SqlDdlReader.g:
					{
					DebugLocation(121, 11);
					input.Consume();


					}
					break;

				default:
					if (cnt2 >= 1)
						goto loop2;

					EarlyExitException eee2 = new EarlyExitException( 2, input );
					DebugRecognitionException(eee2);
					throw eee2;
				}
				cnt2++;
			}
			loop2:
				;

			} finally { DebugExitSubRule(2); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("INT", 18);
			LeaveRule("INT", 18);
			LeaveRule_INT();
		}
	}
	// $ANTLR end "INT"

	partial void EnterRule_COMMENT();
	partial void LeaveRule_COMMENT();

	// $ANTLR start "COMMENT"
	[GrammarRule("COMMENT")]
	private void mCOMMENT()
	{
		EnterRule_COMMENT();
		EnterRule("COMMENT", 19);
		TraceIn("COMMENT", 19);
		try
		{
			int _type = COMMENT;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:124:5: ( '--' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' )
			int alt6=2;
			try { DebugEnterDecision(6, false);
			int LA6_1 = input.LA(1);

			if ((LA6_1=='-'))
			{
				alt6 = 1;
			}
			else if ((LA6_1=='/'))
			{
				alt6 = 2;
			}
			else
			{
				NoViableAltException nvae = new NoViableAltException("", 6, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(6); }
			switch (alt6)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:124:9: '--' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
				{
				DebugLocation(124, 9);
				Match("--"); 

				DebugLocation(124, 14);
				// SqlDdlReader.g:124:14: (~ ( '\\n' | '\\r' ) )*
				try { DebugEnterSubRule(3);
				while (true)
				{
					int alt3=2;
					try { DebugEnterDecision(3, false);
					int LA3_1 = input.LA(1);

					if (((LA3_1>='\u0000' && LA3_1<='\t')||(LA3_1>='\u000B' && LA3_1<='\f')||(LA3_1>='\u000E' && LA3_1<='\uFFFF')))
					{
						alt3 = 1;
					}


					} finally { DebugExitDecision(3); }
					switch ( alt3 )
					{
					case 1:
						DebugEnterAlt(1);
						// SqlDdlReader.g:
						{
						DebugLocation(124, 14);
						input.Consume();


						}
						break;

					default:
						goto loop3;
					}
				}

				loop3:
					;

				} finally { DebugExitSubRule(3); }

				DebugLocation(124, 28);
				// SqlDdlReader.g:124:28: ( '\\r' )?
				int alt4=2;
				try { DebugEnterSubRule(4);
				try { DebugEnterDecision(4, false);
				int LA4_1 = input.LA(1);

				if ((LA4_1=='\r'))
				{
					alt4 = 1;
				}
				} finally { DebugExitDecision(4); }
				switch (alt4)
				{
				case 1:
					DebugEnterAlt(1);
					// SqlDdlReader.g:124:28: '\\r'
					{
					DebugLocation(124, 28);
					Match('\r'); 

					}
					break;

				}
				} finally { DebugExitSubRule(4); }

				DebugLocation(124, 34);
				Match('\n'); 
				DebugLocation(124, 39);
				_channel=Hidden;

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// SqlDdlReader.g:125:9: '/*' ( options {greedy=false; } : . )* '*/'
				{
				DebugLocation(125, 9);
				Match("/*"); 

				DebugLocation(125, 14);
				// SqlDdlReader.g:125:14: ( options {greedy=false; } : . )*
				try { DebugEnterSubRule(5);
				while (true)
				{
					int alt5=2;
					try { DebugEnterDecision(5, false);
					int LA5_1 = input.LA(1);

					if ((LA5_1=='*'))
					{
						int LA5_2 = input.LA(2);

						if ((LA5_2=='/'))
						{
							alt5 = 2;
						}
						else if (((LA5_2>='\u0000' && LA5_2<='.')||(LA5_2>='0' && LA5_2<='\uFFFF')))
						{
							alt5 = 1;
						}


					}
					else if (((LA5_1>='\u0000' && LA5_1<=')')||(LA5_1>='+' && LA5_1<='\uFFFF')))
					{
						alt5 = 1;
					}


					} finally { DebugExitDecision(5); }
					switch ( alt5 )
					{
					case 1:
						DebugEnterAlt(1);
						// SqlDdlReader.g:125:42: .
						{
						DebugLocation(125, 42);
						MatchAny(); 

						}
						break;

					default:
						goto loop5;
					}
				}

				loop5:
					;

				} finally { DebugExitSubRule(5); }

				DebugLocation(125, 47);
				Match("*/"); 

				DebugLocation(125, 52);
				_channel=Hidden;

				}
				break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("COMMENT", 19);
			LeaveRule("COMMENT", 19);
			LeaveRule_COMMENT();
		}
	}
	// $ANTLR end "COMMENT"

	partial void EnterRule_WS();
	partial void LeaveRule_WS();

	// $ANTLR start "WS"
	[GrammarRule("WS")]
	private void mWS()
	{
		EnterRule_WS();
		EnterRule("WS", 20);
		TraceIn("WS", 20);
		try
		{
			int _type = WS;
			int _channel = DefaultTokenChannel;
			// SqlDdlReader.g:128:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )
			DebugEnterAlt(1);
			// SqlDdlReader.g:128:9: ( ' ' | '\\t' | '\\r' | '\\n' )
			{
			DebugLocation(128, 9);
			if ((input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ')
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}

			DebugLocation(132, 11);
			_channel=Hidden;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("WS", 20);
			LeaveRule("WS", 20);
			LeaveRule_WS();
		}
	}
	// $ANTLR end "WS"

	public override void mTokens()
	{
		// SqlDdlReader.g:1:8: ( T__20 | T__21 | T__22 | T__23 | CREATE | TABLE | NOT | NULL | IDENTITY | PRIMARY | KEY | ALTER | ADD | FOREIGN | REFERENCES | CLUSTERED | ID | INT | COMMENT | WS )
		int alt7=20;
		try { DebugEnterDecision(7, false);
		try
		{
			alt7 = dfa7.Predict(input);
		}
		catch (NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
			throw;
		}
		} finally { DebugExitDecision(7); }
		switch (alt7)
		{
		case 1:
			DebugEnterAlt(1);
			// SqlDdlReader.g:1:10: T__20
			{
			DebugLocation(1, 10);
			mT__20(); 

			}
			break;
		case 2:
			DebugEnterAlt(2);
			// SqlDdlReader.g:1:16: T__21
			{
			DebugLocation(1, 16);
			mT__21(); 

			}
			break;
		case 3:
			DebugEnterAlt(3);
			// SqlDdlReader.g:1:22: T__22
			{
			DebugLocation(1, 22);
			mT__22(); 

			}
			break;
		case 4:
			DebugEnterAlt(4);
			// SqlDdlReader.g:1:28: T__23
			{
			DebugLocation(1, 28);
			mT__23(); 

			}
			break;
		case 5:
			DebugEnterAlt(5);
			// SqlDdlReader.g:1:34: CREATE
			{
			DebugLocation(1, 34);
			mCREATE(); 

			}
			break;
		case 6:
			DebugEnterAlt(6);
			// SqlDdlReader.g:1:41: TABLE
			{
			DebugLocation(1, 41);
			mTABLE(); 

			}
			break;
		case 7:
			DebugEnterAlt(7);
			// SqlDdlReader.g:1:47: NOT
			{
			DebugLocation(1, 47);
			mNOT(); 

			}
			break;
		case 8:
			DebugEnterAlt(8);
			// SqlDdlReader.g:1:51: NULL
			{
			DebugLocation(1, 51);
			mNULL(); 

			}
			break;
		case 9:
			DebugEnterAlt(9);
			// SqlDdlReader.g:1:56: IDENTITY
			{
			DebugLocation(1, 56);
			mIDENTITY(); 

			}
			break;
		case 10:
			DebugEnterAlt(10);
			// SqlDdlReader.g:1:65: PRIMARY
			{
			DebugLocation(1, 65);
			mPRIMARY(); 

			}
			break;
		case 11:
			DebugEnterAlt(11);
			// SqlDdlReader.g:1:73: KEY
			{
			DebugLocation(1, 73);
			mKEY(); 

			}
			break;
		case 12:
			DebugEnterAlt(12);
			// SqlDdlReader.g:1:77: ALTER
			{
			DebugLocation(1, 77);
			mALTER(); 

			}
			break;
		case 13:
			DebugEnterAlt(13);
			// SqlDdlReader.g:1:83: ADD
			{
			DebugLocation(1, 83);
			mADD(); 

			}
			break;
		case 14:
			DebugEnterAlt(14);
			// SqlDdlReader.g:1:87: FOREIGN
			{
			DebugLocation(1, 87);
			mFOREIGN(); 

			}
			break;
		case 15:
			DebugEnterAlt(15);
			// SqlDdlReader.g:1:95: REFERENCES
			{
			DebugLocation(1, 95);
			mREFERENCES(); 

			}
			break;
		case 16:
			DebugEnterAlt(16);
			// SqlDdlReader.g:1:106: CLUSTERED
			{
			DebugLocation(1, 106);
			mCLUSTERED(); 

			}
			break;
		case 17:
			DebugEnterAlt(17);
			// SqlDdlReader.g:1:116: ID
			{
			DebugLocation(1, 116);
			mID(); 

			}
			break;
		case 18:
			DebugEnterAlt(18);
			// SqlDdlReader.g:1:119: INT
			{
			DebugLocation(1, 119);
			mINT(); 

			}
			break;
		case 19:
			DebugEnterAlt(19);
			// SqlDdlReader.g:1:123: COMMENT
			{
			DebugLocation(1, 123);
			mCOMMENT(); 

			}
			break;
		case 20:
			DebugEnterAlt(20);
			// SqlDdlReader.g:1:131: WS
			{
			DebugLocation(1, 131);
			mWS(); 

			}
			break;

		}

	}


	#region DFA
	DFA7 dfa7;

	protected override void InitDFAs()
	{
		base.InitDFAs();
		dfa7 = new DFA7(this);
	}

	private class DFA7 : DFA
	{
		private const string DFA7_eotS =
			"\x5\xFFFF\x9\xE\x4\xFFFF\xF\xE\x1\x2D\x3\xE\x1\x31\x1\xE\x1\x33\x5\xE"+
			"\x1\xFFFF\x1\x39\x2\xE\x1\xFFFF\x1\xE\x1\xFFFF\x4\xE\x1\x41\x1\xFFFF"+
			"\x2\xE\x1\x44\x2\xE\x1\x47\x1\xE\x1\xFFFF\x2\xE\x1\xFFFF\x2\xE\x1\xFFFF"+
			"\x2\xE\x1\x4F\x1\x50\x2\xE\x1\x53\x2\xFFFF\x1\xE\x1\x55\x1\xFFFF\x1\xE"+
			"\x1\xFFFF\x1\x57\x1\xFFFF";
		private const string DFA7_eofS =
			"\x58\xFFFF";
		private const string DFA7_minS =
			"\x1\x9\x4\xFFFF\x1\x4C\x1\x41\x1\x4F\x1\x44\x1\x52\x1\x45\x1\x44\x1\x4F"+
			"\x1\x45\x4\xFFFF\x1\x45\x1\x55\x1\x42\x1\x54\x1\x4C\x1\x45\x1\x49\x1"+
			"\x59\x1\x54\x1\x44\x1\x52\x1\x46\x1\x41\x1\x53\x1\x4C\x1\x30\x1\x4C\x1"+
			"\x4E\x1\x4D\x1\x30\x1\x45\x1\x30\x2\x45\x2\x54\x1\x45\x1\xFFFF\x1\x30"+
			"\x1\x54\x1\x41\x1\xFFFF\x1\x52\x1\xFFFF\x1\x49\x1\x52\x2\x45\x1\x30\x1"+
			"\xFFFF\x1\x49\x1\x52\x1\x30\x1\x47\x1\x45\x1\x30\x1\x52\x1\xFFFF\x1\x54"+
			"\x1\x59\x1\xFFFF\x2\x4E\x1\xFFFF\x1\x45\x1\x59\x2\x30\x1\x43\x1\x44\x1"+
			"\x30\x2\xFFFF\x1\x45\x1\x30\x1\xFFFF\x1\x53\x1\xFFFF\x1\x30\x1\xFFFF";
		private const string DFA7_maxS =
			"\x1\x7A\x4\xFFFF\x1\x72\x1\x61\x1\x75\x1\x64\x1\x72\x1\x65\x1\x6C\x1"+
			"\x6F\x1\x65\x4\xFFFF\x1\x65\x1\x75\x1\x62\x1\x74\x1\x6C\x1\x65\x1\x69"+
			"\x1\x79\x1\x74\x1\x64\x1\x72\x1\x66\x1\x61\x1\x73\x1\x6C\x1\x7A\x1\x6C"+
			"\x1\x6E\x1\x6D\x1\x7A\x1\x65\x1\x7A\x2\x65\x2\x74\x1\x65\x1\xFFFF\x1"+
			"\x7A\x1\x74\x1\x61\x1\xFFFF\x1\x72\x1\xFFFF\x1\x69\x1\x72\x2\x65\x1\x7A"+
			"\x1\xFFFF\x1\x69\x1\x72\x1\x7A\x1\x67\x1\x65\x1\x7A\x1\x72\x1\xFFFF\x1"+
			"\x74\x1\x79\x1\xFFFF\x2\x6E\x1\xFFFF\x1\x65\x1\x79\x2\x7A\x1\x63\x1\x64"+
			"\x1\x7A\x2\xFFFF\x1\x65\x1\x7A\x1\xFFFF\x1\x73\x1\xFFFF\x1\x7A\x1\xFFFF";
		private const string DFA7_acceptS =
			"\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x9\xFFFF\x1\x11\x1\x12\x1\x13\x1\x14"+
			"\x1B\xFFFF\x1\x7\x3\xFFFF\x1\xB\x1\xFFFF\x1\xD\x5\xFFFF\x1\x8\x7\xFFFF"+
			"\x1\x6\x2\xFFFF\x1\xC\x2\xFFFF\x1\x5\x7\xFFFF\x1\xA\x1\xE\x2\xFFFF\x1"+
			"\x9\x1\xFFFF\x1\x10\x1\xFFFF\x1\xF";
		private const string DFA7_specialS =
			"\x58\xFFFF}>";
		private static readonly string[] DFA7_transitionS =
			{
				"\x2\x11\x2\xFFFF\x1\x11\x12\xFFFF\x1\x11\x7\xFFFF\x1\x1\x1\x2\x2\xFFFF"+
				"\x1\x3\x1\x10\x1\xFFFF\x1\x10\xA\xF\x1\xFFFF\x1\x4\x5\xFFFF\x1\xB\x1"+
				"\xE\x1\x5\x2\xE\x1\xC\x2\xE\x1\x8\x1\xE\x1\xA\x2\xE\x1\x7\x1\xE\x1\x9"+
				"\x1\xE\x1\xD\x1\xE\x1\x6\x6\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1\xB\x1\xE\x1"+
				"\x5\x2\xE\x1\xC\x2\xE\x1\x8\x1\xE\x1\xA\x2\xE\x1\x7\x1\xE\x1\x9\x1\xE"+
				"\x1\xD\x1\xE\x1\x6\x6\xE",
				"",
				"",
				"",
				"",
				"\x1\x13\x5\xFFFF\x1\x12\x19\xFFFF\x1\x13\x5\xFFFF\x1\x12",
				"\x1\x14\x1F\xFFFF\x1\x14",
				"\x1\x15\x5\xFFFF\x1\x16\x19\xFFFF\x1\x15\x5\xFFFF\x1\x16",
				"\x1\x17\x1F\xFFFF\x1\x17",
				"\x1\x18\x1F\xFFFF\x1\x18",
				"\x1\x19\x1F\xFFFF\x1\x19",
				"\x1\x1B\x7\xFFFF\x1\x1A\x17\xFFFF\x1\x1B\x7\xFFFF\x1\x1A",
				"\x1\x1C\x1F\xFFFF\x1\x1C",
				"\x1\x1D\x1F\xFFFF\x1\x1D",
				"",
				"",
				"",
				"",
				"\x1\x1E\x1F\xFFFF\x1\x1E",
				"\x1\x1F\x1F\xFFFF\x1\x1F",
				"\x1\x20\x1F\xFFFF\x1\x20",
				"\x1\x21\x1F\xFFFF\x1\x21",
				"\x1\x22\x1F\xFFFF\x1\x22",
				"\x1\x23\x1F\xFFFF\x1\x23",
				"\x1\x24\x1F\xFFFF\x1\x24",
				"\x1\x25\x1F\xFFFF\x1\x25",
				"\x1\x26\x1F\xFFFF\x1\x26",
				"\x1\x27\x1F\xFFFF\x1\x27",
				"\x1\x28\x1F\xFFFF\x1\x28",
				"\x1\x29\x1F\xFFFF\x1\x29",
				"\x1\x2A\x1F\xFFFF\x1\x2A",
				"\x1\x2B\x1F\xFFFF\x1\x2B",
				"\x1\x2C\x1F\xFFFF\x1\x2C",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x2E\x1F\xFFFF\x1\x2E",
				"\x1\x2F\x1F\xFFFF\x1\x2F",
				"\x1\x30\x1F\xFFFF\x1\x30",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x32\x1F\xFFFF\x1\x32",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x34\x1F\xFFFF\x1\x34",
				"\x1\x35\x1F\xFFFF\x1\x35",
				"\x1\x36\x1F\xFFFF\x1\x36",
				"\x1\x37\x1F\xFFFF\x1\x37",
				"\x1\x38\x1F\xFFFF\x1\x38",
				"",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x3A\x1F\xFFFF\x1\x3A",
				"\x1\x3B\x1F\xFFFF\x1\x3B",
				"",
				"\x1\x3C\x1F\xFFFF\x1\x3C",
				"",
				"\x1\x3D\x1F\xFFFF\x1\x3D",
				"\x1\x3E\x1F\xFFFF\x1\x3E",
				"\x1\x3F\x1F\xFFFF\x1\x3F",
				"\x1\x40\x1F\xFFFF\x1\x40",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"",
				"\x1\x42\x1F\xFFFF\x1\x42",
				"\x1\x43\x1F\xFFFF\x1\x43",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x45\x1F\xFFFF\x1\x45",
				"\x1\x46\x1F\xFFFF\x1\x46",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x48\x1F\xFFFF\x1\x48",
				"",
				"\x1\x49\x1F\xFFFF\x1\x49",
				"\x1\x4A\x1F\xFFFF\x1\x4A",
				"",
				"\x1\x4B\x1F\xFFFF\x1\x4B",
				"\x1\x4C\x1F\xFFFF\x1\x4C",
				"",
				"\x1\x4D\x1F\xFFFF\x1\x4D",
				"\x1\x4E\x1F\xFFFF\x1\x4E",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"\x1\x51\x1F\xFFFF\x1\x51",
				"\x1\x52\x1F\xFFFF\x1\x52",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"",
				"",
				"\x1\x54\x1F\xFFFF\x1\x54",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				"",
				"\x1\x56\x1F\xFFFF\x1\x56",
				"",
				"\xA\xE\x7\xFFFF\x1A\xE\x4\xFFFF\x1\xE\x1\xFFFF\x1A\xE",
				""
			};

		private static readonly short[] DFA7_eot = DFA.UnpackEncodedString(DFA7_eotS);
		private static readonly short[] DFA7_eof = DFA.UnpackEncodedString(DFA7_eofS);
		private static readonly char[] DFA7_min = DFA.UnpackEncodedStringToUnsignedChars(DFA7_minS);
		private static readonly char[] DFA7_max = DFA.UnpackEncodedStringToUnsignedChars(DFA7_maxS);
		private static readonly short[] DFA7_accept = DFA.UnpackEncodedString(DFA7_acceptS);
		private static readonly short[] DFA7_special = DFA.UnpackEncodedString(DFA7_specialS);
		private static readonly short[][] DFA7_transition;

		static DFA7()
		{
			int numStates = DFA7_transitionS.Length;
			DFA7_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA7_transition[i] = DFA.UnpackEncodedString(DFA7_transitionS[i]);
			}
		}

		public DFA7( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 7;
			this.eot = DFA7_eot;
			this.eof = DFA7_eof;
			this.min = DFA7_min;
			this.max = DFA7_max;
			this.accept = DFA7_accept;
			this.special = DFA7_special;
			this.transition = DFA7_transition;
		}

		public override string Description { get { return "1:1: Tokens : ( T__20 | T__21 | T__22 | T__23 | CREATE | TABLE | NOT | NULL | IDENTITY | PRIMARY | KEY | ALTER | ADD | FOREIGN | REFERENCES | CLUSTERED | ID | INT | COMMENT | WS );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}


	#endregion

}
