//------------------------------------------------------------------------------
// <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:35

// 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 SqlDdlReaderParser : Antlr.Runtime.Parser
{
	internal static readonly string[] tokenNames = new string[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "ADD", "ALTER", "CLUSTERED", "COMMENT", "CREATE", "FOREIGN", "ID", "IDENTITY", "INT", "KEY", "NOT", "NULL", "PRIMARY", "REFERENCES", "TABLE", "WS", "'('", "')'", "','", "';'"
	};
	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;

	public SqlDdlReaderParser(ITokenStream input)
		: this(input, new RecognizerSharedState())
	{
	}
	public SqlDdlReaderParser(ITokenStream input, RecognizerSharedState state)
		: base(input, state)
	{
		OnCreated();
	}

	public override string[] TokenNames { get { return SqlDdlReaderParser.tokenNames; } }
	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);

	#region Rules
	partial void EnterRule_create_tables();
	partial void LeaveRule_create_tables();
	// $ANTLR start "create_tables"
	// SqlDdlReader.g:15:1: create_tables : ( create_table_stmt | alter_table_stmt )* ;
	[GrammarRule("create_tables")]
	private void create_tables()
	{
		EnterRule_create_tables();
		EnterRule("create_tables", 1);
		TraceIn("create_tables", 1);
		try { DebugEnterRule(GrammarFileName, "create_tables");
		DebugLocation(15, 1);
		try
		{
			// SqlDdlReader.g:16:2: ( ( create_table_stmt | alter_table_stmt )* )
			DebugEnterAlt(1);
			// SqlDdlReader.g:16:4: ( create_table_stmt | alter_table_stmt )*
			{
			DebugLocation(16, 4);
			// SqlDdlReader.g:16:4: ( create_table_stmt | alter_table_stmt )*
			try { DebugEnterSubRule(1);
			while (true)
			{
				int alt1=3;
				try { DebugEnterDecision(1, false);
				int LA1_1 = input.LA(1);

				if ((LA1_1==CREATE))
				{
					alt1 = 1;
				}
				else if ((LA1_1==ALTER))
				{
					alt1 = 2;
				}


				} finally { DebugExitDecision(1); }
				switch ( alt1 )
				{
				case 1:
					DebugEnterAlt(1);
					// SqlDdlReader.g:16:5: create_table_stmt
					{
					DebugLocation(16, 5);
					PushFollow(Follow._create_table_stmt_in_create_tables34);
					create_table_stmt();
					PopFollow();


					}
					break;
				case 2:
					DebugEnterAlt(2);
					// SqlDdlReader.g:16:25: alter_table_stmt
					{
					DebugLocation(16, 25);
					PushFollow(Follow._alter_table_stmt_in_create_tables38);
					alter_table_stmt();
					PopFollow();


					}
					break;

				default:
					goto loop1;
				}
			}

			loop1:
				;

			} finally { DebugExitSubRule(1); }


			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("create_tables", 1);
			LeaveRule("create_tables", 1);
			LeaveRule_create_tables();
		}
		DebugLocation(17, 1);
		} finally { DebugExitRule(GrammarFileName, "create_tables"); }
		return;

	}
	// $ANTLR end "create_tables"

	partial void EnterRule_create_table_stmt();
	partial void LeaveRule_create_table_stmt();
	// $ANTLR start "create_table_stmt"
	// SqlDdlReader.g:19:1: create_table_stmt : CREATE TABLE name '(' ( table_content )? ')' ';' ;
	[GrammarRule("create_table_stmt")]
	private void create_table_stmt()
	{
		EnterRule_create_table_stmt();
		EnterRule("create_table_stmt", 2);
		TraceIn("create_table_stmt", 2);
		string name1 = default(string);

		try { DebugEnterRule(GrammarFileName, "create_table_stmt");
		DebugLocation(19, 1);
		try
		{
			// SqlDdlReader.g:20:2: ( CREATE TABLE name '(' ( table_content )? ')' ';' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:20:5: CREATE TABLE name '(' ( table_content )? ')' ';'
			{
			DebugLocation(20, 5);
			Match(input,CREATE,Follow._CREATE_in_create_table_stmt52); 
			DebugLocation(20, 12);
			Match(input,TABLE,Follow._TABLE_in_create_table_stmt54); 
			DebugLocation(20, 18);
			PushFollow(Follow._name_in_create_table_stmt56);
			name1=name();
			PopFollow();

			DebugLocation(20, 23);
			 CreateTable(name1); 
			DebugLocation(21, 3);
			Match(input,20,Follow._20_in_create_table_stmt63); 
			DebugLocation(21, 7);
			// SqlDdlReader.g:21:7: ( table_content )?
			int alt2=2;
			try { DebugEnterSubRule(2);
			try { DebugEnterDecision(2, false);
			int LA2_1 = input.LA(1);

			if ((LA2_1==ID))
			{
				alt2 = 1;
			}
			} finally { DebugExitDecision(2); }
			switch (alt2)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:21:7: table_content
				{
				DebugLocation(21, 7);
				PushFollow(Follow._table_content_in_create_table_stmt65);
				table_content();
				PopFollow();


				}
				break;

			}
			} finally { DebugExitSubRule(2); }

			DebugLocation(21, 22);
			Match(input,21,Follow._21_in_create_table_stmt68); 
			DebugLocation(21, 26);
			Match(input,23,Follow._23_in_create_table_stmt70); 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("create_table_stmt", 2);
			LeaveRule("create_table_stmt", 2);
			LeaveRule_create_table_stmt();
		}
		DebugLocation(22, 1);
		} finally { DebugExitRule(GrammarFileName, "create_table_stmt"); }
		return;

	}
	// $ANTLR end "create_table_stmt"

	partial void EnterRule_table_content();
	partial void LeaveRule_table_content();
	// $ANTLR start "table_content"
	// SqlDdlReader.g:24:1: table_content : table_attribute ( ',' additional_table_element )* ;
	[GrammarRule("table_content")]
	private void table_content()
	{
		EnterRule_table_content();
		EnterRule("table_content", 3);
		TraceIn("table_content", 3);
		try { DebugEnterRule(GrammarFileName, "table_content");
		DebugLocation(24, 1);
		try
		{
			// SqlDdlReader.g:25:2: ( table_attribute ( ',' additional_table_element )* )
			DebugEnterAlt(1);
			// SqlDdlReader.g:25:4: table_attribute ( ',' additional_table_element )*
			{
			DebugLocation(25, 4);
			PushFollow(Follow._table_attribute_in_table_content81);
			table_attribute();
			PopFollow();

			DebugLocation(25, 20);
			// SqlDdlReader.g:25:20: ( ',' additional_table_element )*
			try { DebugEnterSubRule(3);
			while (true)
			{
				int alt3=2;
				try { DebugEnterDecision(3, false);
				int LA3_1 = input.LA(1);

				if ((LA3_1==22))
				{
					alt3 = 1;
				}


				} finally { DebugExitDecision(3); }
				switch ( alt3 )
				{
				case 1:
					DebugEnterAlt(1);
					// SqlDdlReader.g:25:22: ',' additional_table_element
					{
					DebugLocation(25, 22);
					Match(input,22,Follow._22_in_table_content85); 
					DebugLocation(25, 26);
					PushFollow(Follow._additional_table_element_in_table_content87);
					additional_table_element();
					PopFollow();


					}
					break;

				default:
					goto loop3;
				}
			}

			loop3:
				;

			} finally { DebugExitSubRule(3); }


			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("table_content", 3);
			LeaveRule("table_content", 3);
			LeaveRule_table_content();
		}
		DebugLocation(26, 1);
		} finally { DebugExitRule(GrammarFileName, "table_content"); }
		return;

	}
	// $ANTLR end "table_content"

	partial void EnterRule_additional_table_element();
	partial void LeaveRule_additional_table_element();
	// $ANTLR start "additional_table_element"
	// SqlDdlReader.g:28:1: additional_table_element : ( table_attribute | primary_key_def | foreign_key_def );
	[GrammarRule("additional_table_element")]
	private void additional_table_element()
	{
		EnterRule_additional_table_element();
		EnterRule("additional_table_element", 4);
		TraceIn("additional_table_element", 4);
		try { DebugEnterRule(GrammarFileName, "additional_table_element");
		DebugLocation(28, 1);
		try
		{
			// SqlDdlReader.g:29:2: ( table_attribute | primary_key_def | foreign_key_def )
			int alt4=3;
			try { DebugEnterDecision(4, false);
			switch (input.LA(1))
			{
			case ID:
				{
				alt4 = 1;
				}
				break;
			case PRIMARY:
				{
				alt4 = 2;
				}
				break;
			case FOREIGN:
				{
				alt4 = 3;
				}
				break;
			default:
				{
					NoViableAltException nvae = new NoViableAltException("", 4, 0, input, 1);
					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(4); }
			switch (alt4)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:29:4: table_attribute
				{
				DebugLocation(29, 4);
				PushFollow(Follow._table_attribute_in_additional_table_element100);
				table_attribute();
				PopFollow();


				}
				break;
			case 2:
				DebugEnterAlt(2);
				// SqlDdlReader.g:30:5: primary_key_def
				{
				DebugLocation(30, 5);
				PushFollow(Follow._primary_key_def_in_additional_table_element106);
				primary_key_def();
				PopFollow();


				}
				break;
			case 3:
				DebugEnterAlt(3);
				// SqlDdlReader.g:31:4: foreign_key_def
				{
				DebugLocation(31, 4);
				PushFollow(Follow._foreign_key_def_in_additional_table_element111);
				foreign_key_def();
				PopFollow();


				}
				break;

			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("additional_table_element", 4);
			LeaveRule("additional_table_element", 4);
			LeaveRule_additional_table_element();
		}
		DebugLocation(32, 1);
		} finally { DebugExitRule(GrammarFileName, "additional_table_element"); }
		return;

	}
	// $ANTLR end "additional_table_element"

	partial void EnterRule_table_attribute();
	partial void LeaveRule_table_attribute();
	// $ANTLR start "table_attribute"
	// SqlDdlReader.g:35:1: table_attribute : name type ( null_clause )? ( identity_clause )? ( primary_key_clause )? ( foreign_key_clause )? ;
	[GrammarRule("table_attribute")]
	private void table_attribute()
	{
		EnterRule_table_attribute();
		EnterRule("table_attribute", 5);
		TraceIn("table_attribute", 5);
		string name2 = default(string);
		string type3 = default(string);

		try { DebugEnterRule(GrammarFileName, "table_attribute");
		DebugLocation(35, 1);
		try
		{
			// SqlDdlReader.g:36:2: ( name type ( null_clause )? ( identity_clause )? ( primary_key_clause )? ( foreign_key_clause )? )
			DebugEnterAlt(1);
			// SqlDdlReader.g:36:4: name type ( null_clause )? ( identity_clause )? ( primary_key_clause )? ( foreign_key_clause )?
			{
			DebugLocation(36, 4);
			 CreateAttribute(); 
			DebugLocation(37, 3);
			PushFollow(Follow._name_in_table_attribute130);
			name2=name();
			PopFollow();

			DebugLocation(37, 8);
			 CurrentAttribute().Name = name2; 
			DebugLocation(38, 3);
			PushFollow(Follow._type_in_table_attribute137);
			type3=type();
			PopFollow();

			DebugLocation(38, 8);
			 CurrentAttribute().Type = type3; 
			DebugLocation(39, 3);
			// SqlDdlReader.g:39:3: ( null_clause )?
			int alt5=2;
			try { DebugEnterSubRule(5);
			try { DebugEnterDecision(5, false);
			int LA5_1 = input.LA(1);

			if (((LA5_1>=NOT && LA5_1<=NULL)))
			{
				alt5 = 1;
			}
			} finally { DebugExitDecision(5); }
			switch (alt5)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:39:3: null_clause
				{
				DebugLocation(39, 3);
				PushFollow(Follow._null_clause_in_table_attribute144);
				null_clause();
				PopFollow();


				}
				break;

			}
			} finally { DebugExitSubRule(5); }

			DebugLocation(40, 3);
			// SqlDdlReader.g:40:3: ( identity_clause )?
			int alt6=2;
			try { DebugEnterSubRule(6);
			try { DebugEnterDecision(6, false);
			int LA6_1 = input.LA(1);

			if ((LA6_1==IDENTITY))
			{
				alt6 = 1;
			}
			} finally { DebugExitDecision(6); }
			switch (alt6)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:40:3: identity_clause
				{
				DebugLocation(40, 3);
				PushFollow(Follow._identity_clause_in_table_attribute150);
				identity_clause();
				PopFollow();


				}
				break;

			}
			} finally { DebugExitSubRule(6); }

			DebugLocation(41, 3);
			// SqlDdlReader.g:41:3: ( primary_key_clause )?
			int alt7=2;
			try { DebugEnterSubRule(7);
			try { DebugEnterDecision(7, false);
			int LA7_1 = input.LA(1);

			if ((LA7_1==PRIMARY))
			{
				alt7 = 1;
			}
			} finally { DebugExitDecision(7); }
			switch (alt7)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:41:3: primary_key_clause
				{
				DebugLocation(41, 3);
				PushFollow(Follow._primary_key_clause_in_table_attribute155);
				primary_key_clause();
				PopFollow();


				}
				break;

			}
			} finally { DebugExitSubRule(7); }

			DebugLocation(42, 3);
			// SqlDdlReader.g:42:3: ( foreign_key_clause )?
			int alt8=2;
			try { DebugEnterSubRule(8);
			try { DebugEnterDecision(8, false);
			int LA8_1 = input.LA(1);

			if ((LA8_1==FOREIGN))
			{
				alt8 = 1;
			}
			} finally { DebugExitDecision(8); }
			switch (alt8)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:42:3: foreign_key_clause
				{
				DebugLocation(42, 3);
				PushFollow(Follow._foreign_key_clause_in_table_attribute160);
				foreign_key_clause();
				PopFollow();


				}
				break;

			}
			} finally { DebugExitSubRule(8); }


			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("table_attribute", 5);
			LeaveRule("table_attribute", 5);
			LeaveRule_table_attribute();
		}
		DebugLocation(43, 1);
		} finally { DebugExitRule(GrammarFileName, "table_attribute"); }
		return;

	}
	// $ANTLR end "table_attribute"

	partial void EnterRule_name();
	partial void LeaveRule_name();
	// $ANTLR start "name"
	// SqlDdlReader.g:45:1: name returns [string value] : ID ;
	[GrammarRule("name")]
	private string name()
	{
		EnterRule_name();
		EnterRule("name", 6);
		TraceIn("name", 6);
		string value = default(string);


		IToken ID4 = default(IToken);

		try { DebugEnterRule(GrammarFileName, "name");
		DebugLocation(45, 1);
		try
		{
			// SqlDdlReader.g:46:2: ( ID )
			DebugEnterAlt(1);
			// SqlDdlReader.g:46:4: ID
			{
			DebugLocation(46, 4);
			ID4=(IToken)Match(input,ID,Follow._ID_in_name177); 
			DebugLocation(46, 7);
			 value = (ID4!=null?ID4.Text:default(string)); 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("name", 6);
			LeaveRule("name", 6);
			LeaveRule_name();
		}
		DebugLocation(47, 1);
		} finally { DebugExitRule(GrammarFileName, "name"); }
		return value;

	}
	// $ANTLR end "name"

	partial void EnterRule_type();
	partial void LeaveRule_type();
	// $ANTLR start "type"
	// SqlDdlReader.g:49:1: type returns [string value] : ( ID | ID '(' INT ')' );
	[GrammarRule("type")]
	private string type()
	{
		EnterRule_type();
		EnterRule("type", 7);
		TraceIn("type", 7);
		string value = default(string);


		IToken ID5 = default(IToken);
		IToken ID6 = default(IToken);
		IToken INT7 = default(IToken);

		try { DebugEnterRule(GrammarFileName, "type");
		DebugLocation(49, 1);
		try
		{
			// SqlDdlReader.g:50:2: ( ID | ID '(' INT ')' )
			int alt9=2;
			try { DebugEnterDecision(9, false);
			int LA9_1 = input.LA(1);

			if ((LA9_1==ID))
			{
				int LA9_2 = input.LA(2);

				if ((LA9_2==20))
				{
					alt9 = 2;
				}
				else if ((LA9_2==FOREIGN||LA9_2==IDENTITY||(LA9_2>=NOT && LA9_2<=PRIMARY)||(LA9_2>=21 && LA9_2<=22)))
				{
					alt9 = 1;
				}
				else
				{
					NoViableAltException nvae = new NoViableAltException("", 9, 1, input, 2);
					DebugRecognitionException(nvae);
					throw nvae;
				}
			}
			else
			{
				NoViableAltException nvae = new NoViableAltException("", 9, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(9); }
			switch (alt9)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:50:10: ID
				{
				DebugLocation(50, 10);
				ID5=(IToken)Match(input,ID,Follow._ID_in_type201); 
				DebugLocation(50, 13);
				 value = (ID5!=null?ID5.Text:default(string)); 

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// SqlDdlReader.g:51:4: ID '(' INT ')'
				{
				DebugLocation(51, 4);
				ID6=(IToken)Match(input,ID,Follow._ID_in_type208); 
				DebugLocation(51, 7);
				Match(input,20,Follow._20_in_type210); 
				DebugLocation(51, 11);
				INT7=(IToken)Match(input,INT,Follow._INT_in_type212); 
				DebugLocation(51, 15);
				Match(input,21,Follow._21_in_type214); 
				DebugLocation(51, 18);
				 value = (ID6!=null?ID6.Text:default(string)) + '(' + (INT7!=null?INT7.Text:default(string)) + ')'; 

				}
				break;

			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("type", 7);
			LeaveRule("type", 7);
			LeaveRule_type();
		}
		DebugLocation(52, 1);
		} finally { DebugExitRule(GrammarFileName, "type"); }
		return value;

	}
	// $ANTLR end "type"

	partial void EnterRule_null_clause();
	partial void LeaveRule_null_clause();
	// $ANTLR start "null_clause"
	// SqlDdlReader.g:54:1: null_clause : ( NOT NULL | NULL );
	[GrammarRule("null_clause")]
	private void null_clause()
	{
		EnterRule_null_clause();
		EnterRule("null_clause", 8);
		TraceIn("null_clause", 8);
		try { DebugEnterRule(GrammarFileName, "null_clause");
		DebugLocation(54, 1);
		try
		{
			// SqlDdlReader.g:55:2: ( NOT NULL | NULL )
			int alt10=2;
			try { DebugEnterDecision(10, false);
			int LA10_1 = input.LA(1);

			if ((LA10_1==NOT))
			{
				alt10 = 1;
			}
			else if ((LA10_1==NULL))
			{
				alt10 = 2;
			}
			else
			{
				NoViableAltException nvae = new NoViableAltException("", 10, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(10); }
			switch (alt10)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:55:4: NOT NULL
				{
				DebugLocation(55, 4);
				Match(input,NOT,Follow._NOT_in_null_clause226); 
				DebugLocation(55, 8);
				Match(input,NULL,Follow._NULL_in_null_clause228); 
				DebugLocation(55, 13);
				 CurrentAttribute().NotNull = true; 

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// SqlDdlReader.g:56:4: NULL
				{
				DebugLocation(56, 4);
				Match(input,NULL,Follow._NULL_in_null_clause235); 

				}
				break;

			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("null_clause", 8);
			LeaveRule("null_clause", 8);
			LeaveRule_null_clause();
		}
		DebugLocation(57, 1);
		} finally { DebugExitRule(GrammarFileName, "null_clause"); }
		return;

	}
	// $ANTLR end "null_clause"

	partial void EnterRule_identity_clause();
	partial void LeaveRule_identity_clause();
	// $ANTLR start "identity_clause"
	// SqlDdlReader.g:59:1: identity_clause : IDENTITY '(' INT ',' INT ')' ;
	[GrammarRule("identity_clause")]
	private void identity_clause()
	{
		EnterRule_identity_clause();
		EnterRule("identity_clause", 9);
		TraceIn("identity_clause", 9);
		try { DebugEnterRule(GrammarFileName, "identity_clause");
		DebugLocation(59, 1);
		try
		{
			// SqlDdlReader.g:60:2: ( IDENTITY '(' INT ',' INT ')' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:60:5: IDENTITY '(' INT ',' INT ')'
			{
			DebugLocation(60, 5);
			Match(input,IDENTITY,Follow._IDENTITY_in_identity_clause247); 
			DebugLocation(60, 14);
			Match(input,20,Follow._20_in_identity_clause249); 
			DebugLocation(60, 18);
			Match(input,INT,Follow._INT_in_identity_clause251); 
			DebugLocation(60, 22);
			Match(input,22,Follow._22_in_identity_clause253); 
			DebugLocation(60, 26);
			Match(input,INT,Follow._INT_in_identity_clause255); 
			DebugLocation(60, 30);
			Match(input,21,Follow._21_in_identity_clause257); 
			DebugLocation(60, 34);
			 CurrentAttribute().Identity = true; 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("identity_clause", 9);
			LeaveRule("identity_clause", 9);
			LeaveRule_identity_clause();
		}
		DebugLocation(61, 1);
		} finally { DebugExitRule(GrammarFileName, "identity_clause"); }
		return;

	}
	// $ANTLR end "identity_clause"

	partial void EnterRule_primary_key_clause();
	partial void LeaveRule_primary_key_clause();
	// $ANTLR start "primary_key_clause"
	// SqlDdlReader.g:63:1: primary_key_clause : PRIMARY KEY ;
	[GrammarRule("primary_key_clause")]
	private void primary_key_clause()
	{
		EnterRule_primary_key_clause();
		EnterRule("primary_key_clause", 10);
		TraceIn("primary_key_clause", 10);
		try { DebugEnterRule(GrammarFileName, "primary_key_clause");
		DebugLocation(63, 1);
		try
		{
			// SqlDdlReader.g:64:2: ( PRIMARY KEY )
			DebugEnterAlt(1);
			// SqlDdlReader.g:64:5: PRIMARY KEY
			{
			DebugLocation(64, 5);
			Match(input,PRIMARY,Follow._PRIMARY_in_primary_key_clause272); 
			DebugLocation(64, 13);
			Match(input,KEY,Follow._KEY_in_primary_key_clause274); 
			DebugLocation(64, 17);
			 CurrentAttribute().PrimaryKey = true; 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("primary_key_clause", 10);
			LeaveRule("primary_key_clause", 10);
			LeaveRule_primary_key_clause();
		}
		DebugLocation(65, 1);
		} finally { DebugExitRule(GrammarFileName, "primary_key_clause"); }
		return;

	}
	// $ANTLR end "primary_key_clause"

	partial void EnterRule_foreign_key_clause();
	partial void LeaveRule_foreign_key_clause();
	// $ANTLR start "foreign_key_clause"
	// SqlDdlReader.g:67:1: foreign_key_clause : FOREIGN KEY REFERENCES tableRef= name '(' keyRef= name ')' ;
	[GrammarRule("foreign_key_clause")]
	private void foreign_key_clause()
	{
		EnterRule_foreign_key_clause();
		EnterRule("foreign_key_clause", 11);
		TraceIn("foreign_key_clause", 11);
		string tableRef = default(string);
		string keyRef = default(string);

		try { DebugEnterRule(GrammarFileName, "foreign_key_clause");
		DebugLocation(67, 1);
		try
		{
			// SqlDdlReader.g:68:2: ( FOREIGN KEY REFERENCES tableRef= name '(' keyRef= name ')' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:68:4: FOREIGN KEY REFERENCES tableRef= name '(' keyRef= name ')'
			{
			DebugLocation(68, 4);
			Match(input,FOREIGN,Follow._FOREIGN_in_foreign_key_clause287); 
			DebugLocation(68, 12);
			Match(input,KEY,Follow._KEY_in_foreign_key_clause289); 
			DebugLocation(68, 16);
			Match(input,REFERENCES,Follow._REFERENCES_in_foreign_key_clause291); 
			DebugLocation(68, 35);
			PushFollow(Follow._name_in_foreign_key_clause295);
			tableRef=name();
			PopFollow();

			DebugLocation(68, 41);
			Match(input,20,Follow._20_in_foreign_key_clause297); 
			DebugLocation(68, 51);
			PushFollow(Follow._name_in_foreign_key_clause301);
			keyRef=name();
			PopFollow();

			DebugLocation(68, 57);
			Match(input,21,Follow._21_in_foreign_key_clause303); 
			DebugLocation(69, 3);
			 SetForeignKey(tableRef, keyRef); 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("foreign_key_clause", 11);
			LeaveRule("foreign_key_clause", 11);
			LeaveRule_foreign_key_clause();
		}
		DebugLocation(70, 1);
		} finally { DebugExitRule(GrammarFileName, "foreign_key_clause"); }
		return;

	}
	// $ANTLR end "foreign_key_clause"

	partial void EnterRule_primary_key_def();
	partial void LeaveRule_primary_key_def();
	// $ANTLR start "primary_key_def"
	// SqlDdlReader.g:72:1: primary_key_def : PRIMARY KEY ( CLUSTERED )? '(' n1= name ( ',' n2= name )* ')' ;
	[GrammarRule("primary_key_def")]
	private void primary_key_def()
	{
		EnterRule_primary_key_def();
		EnterRule("primary_key_def", 12);
		TraceIn("primary_key_def", 12);
		string n1 = default(string);
		string n2 = default(string);

		try { DebugEnterRule(GrammarFileName, "primary_key_def");
		DebugLocation(72, 1);
		try
		{
			// SqlDdlReader.g:73:2: ( PRIMARY KEY ( CLUSTERED )? '(' n1= name ( ',' n2= name )* ')' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:73:4: PRIMARY KEY ( CLUSTERED )? '(' n1= name ( ',' n2= name )* ')'
			{
			DebugLocation(73, 4);
			Match(input,PRIMARY,Follow._PRIMARY_in_primary_key_def318); 
			DebugLocation(73, 12);
			Match(input,KEY,Follow._KEY_in_primary_key_def320); 
			DebugLocation(73, 16);
			// SqlDdlReader.g:73:16: ( CLUSTERED )?
			int alt11=2;
			try { DebugEnterSubRule(11);
			try { DebugEnterDecision(11, false);
			int LA11_1 = input.LA(1);

			if ((LA11_1==CLUSTERED))
			{
				alt11 = 1;
			}
			} finally { DebugExitDecision(11); }
			switch (alt11)
			{
			case 1:
				DebugEnterAlt(1);
				// SqlDdlReader.g:73:16: CLUSTERED
				{
				DebugLocation(73, 16);
				Match(input,CLUSTERED,Follow._CLUSTERED_in_primary_key_def322); 

				}
				break;

			}
			} finally { DebugExitSubRule(11); }

			DebugLocation(73, 27);
			Match(input,20,Follow._20_in_primary_key_def325); 
			DebugLocation(73, 33);
			PushFollow(Follow._name_in_primary_key_def329);
			n1=name();
			PopFollow();

			DebugLocation(73, 39);
			 SetPrimaryKey(n1); 
			DebugLocation(73, 69);
			// SqlDdlReader.g:73:69: ( ',' n2= name )*
			try { DebugEnterSubRule(12);
			while (true)
			{
				int alt12=2;
				try { DebugEnterDecision(12, false);
				int LA12_1 = input.LA(1);

				if ((LA12_1==22))
				{
					alt12 = 1;
				}


				} finally { DebugExitDecision(12); }
				switch ( alt12 )
				{
				case 1:
					DebugEnterAlt(1);
					// SqlDdlReader.g:73:71: ',' n2= name
					{
					DebugLocation(73, 71);
					Match(input,22,Follow._22_in_primary_key_def335); 
					DebugLocation(73, 77);
					PushFollow(Follow._name_in_primary_key_def339);
					n2=name();
					PopFollow();

					DebugLocation(73, 83);
					 SetPrimaryKey(n2); 

					}
					break;

				default:
					goto loop12;
				}
			}

			loop12:
				;

			} finally { DebugExitSubRule(12); }

			DebugLocation(73, 117);
			Match(input,21,Follow._21_in_primary_key_def347); 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("primary_key_def", 12);
			LeaveRule("primary_key_def", 12);
			LeaveRule_primary_key_def();
		}
		DebugLocation(74, 1);
		} finally { DebugExitRule(GrammarFileName, "primary_key_def"); }
		return;

	}
	// $ANTLR end "primary_key_def"

	partial void EnterRule_foreign_key_def();
	partial void LeaveRule_foreign_key_def();
	// $ANTLR start "foreign_key_def"
	// SqlDdlReader.g:76:1: foreign_key_def : FOREIGN KEY '(' attrName= name ')' REFERENCES tableRef= name '(' keyRef= name ')' ;
	[GrammarRule("foreign_key_def")]
	private void foreign_key_def()
	{
		EnterRule_foreign_key_def();
		EnterRule("foreign_key_def", 13);
		TraceIn("foreign_key_def", 13);
		string attrName = default(string);
		string tableRef = default(string);
		string keyRef = default(string);

		try { DebugEnterRule(GrammarFileName, "foreign_key_def");
		DebugLocation(76, 1);
		try
		{
			// SqlDdlReader.g:77:2: ( FOREIGN KEY '(' attrName= name ')' REFERENCES tableRef= name '(' keyRef= name ')' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:77:4: FOREIGN KEY '(' attrName= name ')' REFERENCES tableRef= name '(' keyRef= name ')'
			{
			DebugLocation(77, 4);
			Match(input,FOREIGN,Follow._FOREIGN_in_foreign_key_def359); 
			DebugLocation(77, 12);
			Match(input,KEY,Follow._KEY_in_foreign_key_def361); 
			DebugLocation(77, 16);
			Match(input,20,Follow._20_in_foreign_key_def363); 
			DebugLocation(77, 28);
			PushFollow(Follow._name_in_foreign_key_def367);
			attrName=name();
			PopFollow();

			DebugLocation(77, 34);
			Match(input,21,Follow._21_in_foreign_key_def369); 
			DebugLocation(77, 38);
			Match(input,REFERENCES,Follow._REFERENCES_in_foreign_key_def371); 
			DebugLocation(77, 57);
			PushFollow(Follow._name_in_foreign_key_def375);
			tableRef=name();
			PopFollow();

			DebugLocation(77, 63);
			Match(input,20,Follow._20_in_foreign_key_def377); 
			DebugLocation(77, 73);
			PushFollow(Follow._name_in_foreign_key_def381);
			keyRef=name();
			PopFollow();

			DebugLocation(77, 79);
			Match(input,21,Follow._21_in_foreign_key_def383); 
			DebugLocation(78, 3);
			 SetForeignKey(attrName, tableRef, keyRef); 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("foreign_key_def", 13);
			LeaveRule("foreign_key_def", 13);
			LeaveRule_foreign_key_def();
		}
		DebugLocation(79, 1);
		} finally { DebugExitRule(GrammarFileName, "foreign_key_def"); }
		return;

	}
	// $ANTLR end "foreign_key_def"

	partial void EnterRule_alter_table_stmt();
	partial void LeaveRule_alter_table_stmt();
	// $ANTLR start "alter_table_stmt"
	// SqlDdlReader.g:81:1: alter_table_stmt : foreign_key_stmt ;
	[GrammarRule("alter_table_stmt")]
	private void alter_table_stmt()
	{
		EnterRule_alter_table_stmt();
		EnterRule("alter_table_stmt", 14);
		TraceIn("alter_table_stmt", 14);
		try { DebugEnterRule(GrammarFileName, "alter_table_stmt");
		DebugLocation(81, 1);
		try
		{
			// SqlDdlReader.g:82:2: ( foreign_key_stmt )
			DebugEnterAlt(1);
			// SqlDdlReader.g:82:4: foreign_key_stmt
			{
			DebugLocation(82, 4);
			PushFollow(Follow._foreign_key_stmt_in_alter_table_stmt400);
			foreign_key_stmt();
			PopFollow();


			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("alter_table_stmt", 14);
			LeaveRule("alter_table_stmt", 14);
			LeaveRule_alter_table_stmt();
		}
		DebugLocation(83, 1);
		} finally { DebugExitRule(GrammarFileName, "alter_table_stmt"); }
		return;

	}
	// $ANTLR end "alter_table_stmt"

	partial void EnterRule_foreign_key_stmt();
	partial void LeaveRule_foreign_key_stmt();
	// $ANTLR start "foreign_key_stmt"
	// SqlDdlReader.g:85:1: foreign_key_stmt : ALTER TABLE tableName= name ADD FOREIGN KEY '(' attrName= name ')' REFERENCES tableRef= name '(' keyRef= name ')' ;
	[GrammarRule("foreign_key_stmt")]
	private void foreign_key_stmt()
	{
		EnterRule_foreign_key_stmt();
		EnterRule("foreign_key_stmt", 15);
		TraceIn("foreign_key_stmt", 15);
		string tableName = default(string);
		string attrName = default(string);
		string tableRef = default(string);
		string keyRef = default(string);

		try { DebugEnterRule(GrammarFileName, "foreign_key_stmt");
		DebugLocation(85, 1);
		try
		{
			// SqlDdlReader.g:86:2: ( ALTER TABLE tableName= name ADD FOREIGN KEY '(' attrName= name ')' REFERENCES tableRef= name '(' keyRef= name ')' )
			DebugEnterAlt(1);
			// SqlDdlReader.g:86:4: ALTER TABLE tableName= name ADD FOREIGN KEY '(' attrName= name ')' REFERENCES tableRef= name '(' keyRef= name ')'
			{
			DebugLocation(86, 4);
			Match(input,ALTER,Follow._ALTER_in_foreign_key_stmt412); 
			DebugLocation(86, 10);
			Match(input,TABLE,Follow._TABLE_in_foreign_key_stmt414); 
			DebugLocation(86, 25);
			PushFollow(Follow._name_in_foreign_key_stmt418);
			tableName=name();
			PopFollow();

			DebugLocation(86, 31);
			Match(input,ADD,Follow._ADD_in_foreign_key_stmt420); 
			DebugLocation(86, 35);
			Match(input,FOREIGN,Follow._FOREIGN_in_foreign_key_stmt422); 
			DebugLocation(86, 43);
			Match(input,KEY,Follow._KEY_in_foreign_key_stmt424); 
			DebugLocation(86, 47);
			Match(input,20,Follow._20_in_foreign_key_stmt426); 
			DebugLocation(86, 59);
			PushFollow(Follow._name_in_foreign_key_stmt430);
			attrName=name();
			PopFollow();

			DebugLocation(86, 65);
			Match(input,21,Follow._21_in_foreign_key_stmt432); 
			DebugLocation(86, 69);
			Match(input,REFERENCES,Follow._REFERENCES_in_foreign_key_stmt434); 
			DebugLocation(86, 88);
			PushFollow(Follow._name_in_foreign_key_stmt438);
			tableRef=name();
			PopFollow();

			DebugLocation(86, 94);
			Match(input,20,Follow._20_in_foreign_key_stmt440); 
			DebugLocation(86, 104);
			PushFollow(Follow._name_in_foreign_key_stmt444);
			keyRef=name();
			PopFollow();

			DebugLocation(86, 110);
			Match(input,21,Follow._21_in_foreign_key_stmt446); 
			DebugLocation(87, 3);
			 SetForeignKey(tableName, attrName, tableRef, keyRef); 

			}

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		}
		finally
		{
			TraceOut("foreign_key_stmt", 15);
			LeaveRule("foreign_key_stmt", 15);
			LeaveRule_foreign_key_stmt();
		}
		DebugLocation(88, 1);
		} finally { DebugExitRule(GrammarFileName, "foreign_key_stmt"); }
		return;

	}
	// $ANTLR end "foreign_key_stmt"
	#endregion Rules


	#region Follow sets
	private static class Follow
	{
		public static readonly BitSet _create_table_stmt_in_create_tables34 = new BitSet(new ulong[]{0x122UL});
		public static readonly BitSet _alter_table_stmt_in_create_tables38 = new BitSet(new ulong[]{0x122UL});
		public static readonly BitSet _CREATE_in_create_table_stmt52 = new BitSet(new ulong[]{0x40000UL});
		public static readonly BitSet _TABLE_in_create_table_stmt54 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_create_table_stmt56 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_create_table_stmt63 = new BitSet(new ulong[]{0x200400UL});
		public static readonly BitSet _table_content_in_create_table_stmt65 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_create_table_stmt68 = new BitSet(new ulong[]{0x800000UL});
		public static readonly BitSet _23_in_create_table_stmt70 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _table_attribute_in_table_content81 = new BitSet(new ulong[]{0x400002UL});
		public static readonly BitSet _22_in_table_content85 = new BitSet(new ulong[]{0x10600UL});
		public static readonly BitSet _additional_table_element_in_table_content87 = new BitSet(new ulong[]{0x400002UL});
		public static readonly BitSet _table_attribute_in_additional_table_element100 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _primary_key_def_in_additional_table_element106 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _foreign_key_def_in_additional_table_element111 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _name_in_table_attribute130 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _type_in_table_attribute137 = new BitSet(new ulong[]{0x1CA02UL});
		public static readonly BitSet _null_clause_in_table_attribute144 = new BitSet(new ulong[]{0x10A02UL});
		public static readonly BitSet _identity_clause_in_table_attribute150 = new BitSet(new ulong[]{0x10202UL});
		public static readonly BitSet _primary_key_clause_in_table_attribute155 = new BitSet(new ulong[]{0x202UL});
		public static readonly BitSet _foreign_key_clause_in_table_attribute160 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ID_in_name177 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ID_in_type201 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ID_in_type208 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_type210 = new BitSet(new ulong[]{0x1000UL});
		public static readonly BitSet _INT_in_type212 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_type214 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _NOT_in_null_clause226 = new BitSet(new ulong[]{0x8000UL});
		public static readonly BitSet _NULL_in_null_clause228 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _NULL_in_null_clause235 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _IDENTITY_in_identity_clause247 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_identity_clause249 = new BitSet(new ulong[]{0x1000UL});
		public static readonly BitSet _INT_in_identity_clause251 = new BitSet(new ulong[]{0x400000UL});
		public static readonly BitSet _22_in_identity_clause253 = new BitSet(new ulong[]{0x1000UL});
		public static readonly BitSet _INT_in_identity_clause255 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_identity_clause257 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _PRIMARY_in_primary_key_clause272 = new BitSet(new ulong[]{0x2000UL});
		public static readonly BitSet _KEY_in_primary_key_clause274 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _FOREIGN_in_foreign_key_clause287 = new BitSet(new ulong[]{0x2000UL});
		public static readonly BitSet _KEY_in_foreign_key_clause289 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _REFERENCES_in_foreign_key_clause291 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_clause295 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_foreign_key_clause297 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_clause301 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_foreign_key_clause303 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _PRIMARY_in_primary_key_def318 = new BitSet(new ulong[]{0x2000UL});
		public static readonly BitSet _KEY_in_primary_key_def320 = new BitSet(new ulong[]{0x100040UL});
		public static readonly BitSet _CLUSTERED_in_primary_key_def322 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_primary_key_def325 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_primary_key_def329 = new BitSet(new ulong[]{0x600000UL});
		public static readonly BitSet _22_in_primary_key_def335 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_primary_key_def339 = new BitSet(new ulong[]{0x600000UL});
		public static readonly BitSet _21_in_primary_key_def347 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _FOREIGN_in_foreign_key_def359 = new BitSet(new ulong[]{0x2000UL});
		public static readonly BitSet _KEY_in_foreign_key_def361 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_foreign_key_def363 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_def367 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_foreign_key_def369 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _REFERENCES_in_foreign_key_def371 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_def375 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_foreign_key_def377 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_def381 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_foreign_key_def383 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _foreign_key_stmt_in_alter_table_stmt400 = new BitSet(new ulong[]{0x2UL});
		public static readonly BitSet _ALTER_in_foreign_key_stmt412 = new BitSet(new ulong[]{0x40000UL});
		public static readonly BitSet _TABLE_in_foreign_key_stmt414 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_stmt418 = new BitSet(new ulong[]{0x10UL});
		public static readonly BitSet _ADD_in_foreign_key_stmt420 = new BitSet(new ulong[]{0x200UL});
		public static readonly BitSet _FOREIGN_in_foreign_key_stmt422 = new BitSet(new ulong[]{0x2000UL});
		public static readonly BitSet _KEY_in_foreign_key_stmt424 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_foreign_key_stmt426 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_stmt430 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_foreign_key_stmt432 = new BitSet(new ulong[]{0x20000UL});
		public static readonly BitSet _REFERENCES_in_foreign_key_stmt434 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_stmt438 = new BitSet(new ulong[]{0x100000UL});
		public static readonly BitSet _20_in_foreign_key_stmt440 = new BitSet(new ulong[]{0x400UL});
		public static readonly BitSet _name_in_foreign_key_stmt444 = new BitSet(new ulong[]{0x200000UL});
		public static readonly BitSet _21_in_foreign_key_stmt446 = new BitSet(new ulong[]{0x2UL});
	}
	#endregion Follow sets
}
