package com.justeat.mickeydb.ide.contentassist.antlr.internal;

import java.io.InputStream;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.parser.antlr.XtextTokenStream;
import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
import com.justeat.mickeydb.services.MickeyLangGrammarAccess;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
@SuppressWarnings("all")
public class InternalMickeyLangParser extends AbstractInternalContentAssistParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_NUMBER", "RULE_ID", "RULE_STRING", "RULE_INT", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'*'", "'/'", "'%'", "'+'", "'-'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'", "'>='", "'='", "'=='", "'!='", "'<>'", "'is'", "'is not'", "'in'", "'not in'", "'like'", "'glob'", "'match'", "'regexp'", "'not null'", "'notnull'", "'offset'", "','", "'before'", "'after'", "'instead of'", "'replace'", "'union all'", "'union'", "'intersect'", "'except'", "'text'", "'integer'", "'real'", "'blob'", "'none'", "'numeric'", "'boolean'", "'rollback'", "'abort'", "'fail'", "'ignore'", "'database'", "'function'", "'('", "')'", "'{'", "'}'", "':'", "';'", "'action'", "'on'", "'notify'", "'param'", "'migrate'", "'from'", "'is null'", "'new.'", "'old.'", "'.'", "'case'", "'end'", "'else'", "'cast'", "'as'", "'$'", "'when'", "'then'", "'order by'", "'limit'", "'select'", "'where'", "'group by'", "'having'", "'join'", "'create'", "'table'", "'view'", "'trigger'", "'begin'", "'of'", "'alter'", "'rename to'", "'add column'", "'drop'", "'index'", "'primary key'", "'unique'", "'default'", "'check'", "'constraint'", "'collate'", "'conflict'", "'delete'", "'into'", "'insert'", "'or'", "'values'", "'update'", "'set'", "'||'", "'and'", "'not'", "'exists'", "'distinct'", "'all'", "'asc'", "'desc'", "'natural'", "'left'", "'outer'", "'inner'", "'cross'", "'null'", "'current_time'", "'current_date'", "'current_timestamp'", "'temp'", "'for each row'", "'if exists'", "'autoincrement'"
    };
    public static final int T__50=50;
    public static final int T__59=59;
    public static final int T__55=55;
    public static final int T__56=56;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__137=137;
    public static final int T__52=52;
    public static final int T__136=136;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int T__138=138;
    public static final int T__133=133;
    public static final int T__132=132;
    public static final int T__60=60;
    public static final int T__135=135;
    public static final int T__61=61;
    public static final int T__134=134;
    public static final int RULE_ID=5;
    public static final int T__131=131;
    public static final int T__130=130;
    public static final int RULE_INT=7;
    public static final int T__66=66;
    public static final int RULE_ML_COMMENT=8;
    public static final int T__67=67;
    public static final int T__129=129;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__62=62;
    public static final int T__126=126;
    public static final int T__63=63;
    public static final int T__125=125;
    public static final int T__64=64;
    public static final int T__128=128;
    public static final int T__65=65;
    public static final int T__127=127;
    public static final int T__37=37;
    public static final int T__38=38;
    public static final int T__39=39;
    public static final int T__33=33;
    public static final int T__34=34;
    public static final int T__35=35;
    public static final int T__36=36;
    public static final int T__30=30;
    public static final int T__31=31;
    public static final int T__32=32;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int T__44=44;
    public static final int T__45=45;
    public static final int T__46=46;
    public static final int T__47=47;
    public static final int T__40=40;
    public static final int T__41=41;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int T__91=91;
    public static final int T__100=100;
    public static final int T__92=92;
    public static final int T__93=93;
    public static final int T__102=102;
    public static final int T__94=94;
    public static final int T__101=101;
    public static final int T__90=90;
    public static final int T__19=19;
    public static final int T__15=15;
    public static final int T__16=16;
    public static final int T__17=17;
    public static final int T__18=18;
    public static final int T__99=99;
    public static final int T__12=12;
    public static final int T__13=13;
    public static final int T__14=14;
    public static final int T__95=95;
    public static final int T__96=96;
    public static final int T__97=97;
    public static final int T__98=98;
    public static final int T__26=26;
    public static final int T__27=27;
    public static final int T__28=28;
    public static final int T__29=29;
    public static final int T__22=22;
    public static final int T__23=23;
    public static final int T__24=24;
    public static final int T__25=25;
    public static final int T__20=20;
    public static final int T__21=21;
    public static final int T__122=122;
    public static final int T__70=70;
    public static final int T__121=121;
    public static final int T__71=71;
    public static final int T__124=124;
    public static final int T__72=72;
    public static final int T__123=123;
    public static final int T__120=120;
    public static final int RULE_STRING=6;
    public static final int RULE_SL_COMMENT=9;
    public static final int T__77=77;
    public static final int T__119=119;
    public static final int T__78=78;
    public static final int T__118=118;
    public static final int T__79=79;
    public static final int T__73=73;
    public static final int T__115=115;
    public static final int EOF=-1;
    public static final int T__74=74;
    public static final int T__114=114;
    public static final int T__75=75;
    public static final int T__117=117;
    public static final int T__76=76;
    public static final int T__116=116;
    public static final int T__80=80;
    public static final int T__111=111;
    public static final int T__81=81;
    public static final int T__110=110;
    public static final int T__82=82;
    public static final int T__113=113;
    public static final int T__83=83;
    public static final int T__112=112;
    public static final int RULE_WS=10;
    public static final int RULE_ANY_OTHER=11;
    public static final int RULE_NUMBER=4;
    public static final int T__88=88;
    public static final int T__108=108;
    public static final int T__89=89;
    public static final int T__107=107;
    public static final int T__109=109;
    public static final int T__84=84;
    public static final int T__104=104;
    public static final int T__85=85;
    public static final int T__103=103;
    public static final int T__86=86;
    public static final int T__106=106;
    public static final int T__87=87;
    public static final int T__105=105;

    // delegates
    // delegators


        public InternalMickeyLangParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public InternalMickeyLangParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        

    public String[] getTokenNames() { return InternalMickeyLangParser.tokenNames; }
    public String getGrammarFileName() { return "InternalMickeyLang.g"; }


    	private MickeyLangGrammarAccess grammarAccess;

    	public void setGrammarAccess(MickeyLangGrammarAccess grammarAccess) {
    		this.grammarAccess = grammarAccess;
    	}

    	@Override
    	protected Grammar getGrammar() {
    		return grammarAccess.getGrammar();
    	}

    	@Override
    	protected String getValueForTokenName(String tokenName) {
    		return tokenName;
    	}



    // $ANTLR start "entryRuleMickeyFile"
    // InternalMickeyLang.g:54:1: entryRuleMickeyFile : ruleMickeyFile EOF ;
    public final void entryRuleMickeyFile() throws RecognitionException {
        try {
            // InternalMickeyLang.g:55:1: ( ruleMickeyFile EOF )
            // InternalMickeyLang.g:56:1: ruleMickeyFile EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMickeyFile();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMickeyFile"


    // $ANTLR start "ruleMickeyFile"
    // InternalMickeyLang.g:63:1: ruleMickeyFile : ( ( rule__MickeyFile__Group__0 ) ) ;
    public final void ruleMickeyFile() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:67:2: ( ( ( rule__MickeyFile__Group__0 ) ) )
            // InternalMickeyLang.g:68:2: ( ( rule__MickeyFile__Group__0 ) )
            {
            // InternalMickeyLang.g:68:2: ( ( rule__MickeyFile__Group__0 ) )
            // InternalMickeyLang.g:69:3: ( rule__MickeyFile__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileAccess().getGroup()); 
            }
            // InternalMickeyLang.g:70:3: ( rule__MickeyFile__Group__0 )
            // InternalMickeyLang.g:70:4: rule__MickeyFile__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFile__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMickeyFile"


    // $ANTLR start "entryRuleMickeyBlock"
    // InternalMickeyLang.g:79:1: entryRuleMickeyBlock : ruleMickeyBlock EOF ;
    public final void entryRuleMickeyBlock() throws RecognitionException {
        try {
            // InternalMickeyLang.g:80:1: ( ruleMickeyBlock EOF )
            // InternalMickeyLang.g:81:1: ruleMickeyBlock EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyBlockRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMickeyBlock();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyBlockRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMickeyBlock"


    // $ANTLR start "ruleMickeyBlock"
    // InternalMickeyLang.g:88:1: ruleMickeyBlock : ( ( rule__MickeyBlock__Alternatives ) ) ;
    public final void ruleMickeyBlock() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:92:2: ( ( ( rule__MickeyBlock__Alternatives ) ) )
            // InternalMickeyLang.g:93:2: ( ( rule__MickeyBlock__Alternatives ) )
            {
            // InternalMickeyLang.g:93:2: ( ( rule__MickeyBlock__Alternatives ) )
            // InternalMickeyLang.g:94:3: ( rule__MickeyBlock__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyBlockAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:95:3: ( rule__MickeyBlock__Alternatives )
            // InternalMickeyLang.g:95:4: rule__MickeyBlock__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__MickeyBlock__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyBlockAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMickeyBlock"


    // $ANTLR start "entryRuleMickeyFunction"
    // InternalMickeyLang.g:104:1: entryRuleMickeyFunction : ruleMickeyFunction EOF ;
    public final void entryRuleMickeyFunction() throws RecognitionException {
        try {
            // InternalMickeyLang.g:105:1: ( ruleMickeyFunction EOF )
            // InternalMickeyLang.g:106:1: ruleMickeyFunction EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMickeyFunction();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMickeyFunction"


    // $ANTLR start "ruleMickeyFunction"
    // InternalMickeyLang.g:113:1: ruleMickeyFunction : ( ( rule__MickeyFunction__Group__0 ) ) ;
    public final void ruleMickeyFunction() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:117:2: ( ( ( rule__MickeyFunction__Group__0 ) ) )
            // InternalMickeyLang.g:118:2: ( ( rule__MickeyFunction__Group__0 ) )
            {
            // InternalMickeyLang.g:118:2: ( ( rule__MickeyFunction__Group__0 ) )
            // InternalMickeyLang.g:119:3: ( rule__MickeyFunction__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getGroup()); 
            }
            // InternalMickeyLang.g:120:3: ( rule__MickeyFunction__Group__0 )
            // InternalMickeyLang.g:120:4: rule__MickeyFunction__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMickeyFunction"


    // $ANTLR start "entryRuleActionStatement"
    // InternalMickeyLang.g:129:1: entryRuleActionStatement : ruleActionStatement EOF ;
    public final void entryRuleActionStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:130:1: ( ruleActionStatement EOF )
            // InternalMickeyLang.g:131:1: ruleActionStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleActionStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleActionStatement"


    // $ANTLR start "ruleActionStatement"
    // InternalMickeyLang.g:138:1: ruleActionStatement : ( ( rule__ActionStatement__Group__0 ) ) ;
    public final void ruleActionStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:142:2: ( ( ( rule__ActionStatement__Group__0 ) ) )
            // InternalMickeyLang.g:143:2: ( ( rule__ActionStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:143:2: ( ( rule__ActionStatement__Group__0 ) )
            // InternalMickeyLang.g:144:3: ( rule__ActionStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:145:3: ( rule__ActionStatement__Group__0 )
            // InternalMickeyLang.g:145:4: rule__ActionStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleActionStatement"


    // $ANTLR start "entryRuleContentNotificationUri"
    // InternalMickeyLang.g:154:1: entryRuleContentNotificationUri : ruleContentNotificationUri EOF ;
    public final void entryRuleContentNotificationUri() throws RecognitionException {
        try {
            // InternalMickeyLang.g:155:1: ( ruleContentNotificationUri EOF )
            // InternalMickeyLang.g:156:1: ruleContentNotificationUri EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentNotificationUriRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleContentNotificationUri();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentNotificationUriRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleContentNotificationUri"


    // $ANTLR start "ruleContentNotificationUri"
    // InternalMickeyLang.g:163:1: ruleContentNotificationUri : ( ( rule__ContentNotificationUri__Group__0 ) ) ;
    public final void ruleContentNotificationUri() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:167:2: ( ( ( rule__ContentNotificationUri__Group__0 ) ) )
            // InternalMickeyLang.g:168:2: ( ( rule__ContentNotificationUri__Group__0 ) )
            {
            // InternalMickeyLang.g:168:2: ( ( rule__ContentNotificationUri__Group__0 ) )
            // InternalMickeyLang.g:169:3: ( rule__ContentNotificationUri__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentNotificationUriAccess().getGroup()); 
            }
            // InternalMickeyLang.g:170:3: ( rule__ContentNotificationUri__Group__0 )
            // InternalMickeyLang.g:170:4: rule__ContentNotificationUri__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ContentNotificationUri__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentNotificationUriAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleContentNotificationUri"


    // $ANTLR start "entryRuleFunctionArg"
    // InternalMickeyLang.g:179:1: entryRuleFunctionArg : ruleFunctionArg EOF ;
    public final void entryRuleFunctionArg() throws RecognitionException {
        try {
            // InternalMickeyLang.g:180:1: ( ruleFunctionArg EOF )
            // InternalMickeyLang.g:181:1: ruleFunctionArg EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFunctionArgRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleFunctionArg();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFunctionArgRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleFunctionArg"


    // $ANTLR start "ruleFunctionArg"
    // InternalMickeyLang.g:188:1: ruleFunctionArg : ( ( rule__FunctionArg__Group__0 ) ) ;
    public final void ruleFunctionArg() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:192:2: ( ( ( rule__FunctionArg__Group__0 ) ) )
            // InternalMickeyLang.g:193:2: ( ( rule__FunctionArg__Group__0 ) )
            {
            // InternalMickeyLang.g:193:2: ( ( rule__FunctionArg__Group__0 ) )
            // InternalMickeyLang.g:194:3: ( rule__FunctionArg__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFunctionArgAccess().getGroup()); 
            }
            // InternalMickeyLang.g:195:3: ( rule__FunctionArg__Group__0 )
            // InternalMickeyLang.g:195:4: rule__FunctionArg__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__FunctionArg__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getFunctionArgAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleFunctionArg"


    // $ANTLR start "entryRuleNotifyContentUri"
    // InternalMickeyLang.g:204:1: entryRuleNotifyContentUri : ruleNotifyContentUri EOF ;
    public final void entryRuleNotifyContentUri() throws RecognitionException {
        try {
            // InternalMickeyLang.g:205:1: ( ruleNotifyContentUri EOF )
            // InternalMickeyLang.g:206:1: ruleNotifyContentUri EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNotifyContentUri();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNotifyContentUri"


    // $ANTLR start "ruleNotifyContentUri"
    // InternalMickeyLang.g:213:1: ruleNotifyContentUri : ( ( rule__NotifyContentUri__Group__0 ) ) ;
    public final void ruleNotifyContentUri() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:217:2: ( ( ( rule__NotifyContentUri__Group__0 ) ) )
            // InternalMickeyLang.g:218:2: ( ( rule__NotifyContentUri__Group__0 ) )
            {
            // InternalMickeyLang.g:218:2: ( ( rule__NotifyContentUri__Group__0 ) )
            // InternalMickeyLang.g:219:3: ( rule__NotifyContentUri__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getGroup()); 
            }
            // InternalMickeyLang.g:220:3: ( rule__NotifyContentUri__Group__0 )
            // InternalMickeyLang.g:220:4: rule__NotifyContentUri__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNotifyContentUri"


    // $ANTLR start "entryRuleNotifyContentUriSegment"
    // InternalMickeyLang.g:229:1: entryRuleNotifyContentUriSegment : ruleNotifyContentUriSegment EOF ;
    public final void entryRuleNotifyContentUriSegment() throws RecognitionException {
        try {
            // InternalMickeyLang.g:230:1: ( ruleNotifyContentUriSegment EOF )
            // InternalMickeyLang.g:231:1: ruleNotifyContentUriSegment EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNotifyContentUriSegment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNotifyContentUriSegment"


    // $ANTLR start "ruleNotifyContentUriSegment"
    // InternalMickeyLang.g:238:1: ruleNotifyContentUriSegment : ( ( rule__NotifyContentUriSegment__Alternatives ) ) ;
    public final void ruleNotifyContentUriSegment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:242:2: ( ( ( rule__NotifyContentUriSegment__Alternatives ) ) )
            // InternalMickeyLang.g:243:2: ( ( rule__NotifyContentUriSegment__Alternatives ) )
            {
            // InternalMickeyLang.g:243:2: ( ( rule__NotifyContentUriSegment__Alternatives ) )
            // InternalMickeyLang.g:244:3: ( rule__NotifyContentUriSegment__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:245:3: ( rule__NotifyContentUriSegment__Alternatives )
            // InternalMickeyLang.g:245:4: rule__NotifyContentUriSegment__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUriSegment__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNotifyContentUriSegment"


    // $ANTLR start "entryRuleContentUri"
    // InternalMickeyLang.g:254:1: entryRuleContentUri : ruleContentUri EOF ;
    public final void entryRuleContentUri() throws RecognitionException {
        try {
            // InternalMickeyLang.g:255:1: ( ruleContentUri EOF )
            // InternalMickeyLang.g:256:1: ruleContentUri EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleContentUri();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleContentUri"


    // $ANTLR start "ruleContentUri"
    // InternalMickeyLang.g:263:1: ruleContentUri : ( ( rule__ContentUri__Group__0 ) ) ;
    public final void ruleContentUri() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:267:2: ( ( ( rule__ContentUri__Group__0 ) ) )
            // InternalMickeyLang.g:268:2: ( ( rule__ContentUri__Group__0 ) )
            {
            // InternalMickeyLang.g:268:2: ( ( rule__ContentUri__Group__0 ) )
            // InternalMickeyLang.g:269:3: ( rule__ContentUri__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getGroup()); 
            }
            // InternalMickeyLang.g:270:3: ( rule__ContentUri__Group__0 )
            // InternalMickeyLang.g:270:4: rule__ContentUri__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ContentUri__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleContentUri"


    // $ANTLR start "entryRuleContentUriQueryParam"
    // InternalMickeyLang.g:279:1: entryRuleContentUriQueryParam : ruleContentUriQueryParam EOF ;
    public final void entryRuleContentUriQueryParam() throws RecognitionException {
        try {
            // InternalMickeyLang.g:280:1: ( ruleContentUriQueryParam EOF )
            // InternalMickeyLang.g:281:1: ruleContentUriQueryParam EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleContentUriQueryParam();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleContentUriQueryParam"


    // $ANTLR start "ruleContentUriQueryParam"
    // InternalMickeyLang.g:288:1: ruleContentUriQueryParam : ( ( rule__ContentUriQueryParam__Group__0 ) ) ;
    public final void ruleContentUriQueryParam() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:292:2: ( ( ( rule__ContentUriQueryParam__Group__0 ) ) )
            // InternalMickeyLang.g:293:2: ( ( rule__ContentUriQueryParam__Group__0 ) )
            {
            // InternalMickeyLang.g:293:2: ( ( rule__ContentUriQueryParam__Group__0 ) )
            // InternalMickeyLang.g:294:3: ( rule__ContentUriQueryParam__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getGroup()); 
            }
            // InternalMickeyLang.g:295:3: ( rule__ContentUriQueryParam__Group__0 )
            // InternalMickeyLang.g:295:4: rule__ContentUriQueryParam__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ContentUriQueryParam__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleContentUriQueryParam"


    // $ANTLR start "entryRuleContentUriSegment"
    // InternalMickeyLang.g:304:1: entryRuleContentUriSegment : ruleContentUriSegment EOF ;
    public final void entryRuleContentUriSegment() throws RecognitionException {
        try {
            // InternalMickeyLang.g:305:1: ( ruleContentUriSegment EOF )
            // InternalMickeyLang.g:306:1: ruleContentUriSegment EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleContentUriSegment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleContentUriSegment"


    // $ANTLR start "ruleContentUriSegment"
    // InternalMickeyLang.g:313:1: ruleContentUriSegment : ( ( rule__ContentUriSegment__Alternatives ) ) ;
    public final void ruleContentUriSegment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:317:2: ( ( ( rule__ContentUriSegment__Alternatives ) ) )
            // InternalMickeyLang.g:318:2: ( ( rule__ContentUriSegment__Alternatives ) )
            {
            // InternalMickeyLang.g:318:2: ( ( rule__ContentUriSegment__Alternatives ) )
            // InternalMickeyLang.g:319:3: ( rule__ContentUriSegment__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:320:3: ( rule__ContentUriSegment__Alternatives )
            // InternalMickeyLang.g:320:4: rule__ContentUriSegment__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ContentUriSegment__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleContentUriSegment"


    // $ANTLR start "entryRuleMigrationBlock"
    // InternalMickeyLang.g:329:1: entryRuleMigrationBlock : ruleMigrationBlock EOF ;
    public final void entryRuleMigrationBlock() throws RecognitionException {
        try {
            // InternalMickeyLang.g:330:1: ( ruleMigrationBlock EOF )
            // InternalMickeyLang.g:331:1: ruleMigrationBlock EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMigrationBlock();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMigrationBlock"


    // $ANTLR start "ruleMigrationBlock"
    // InternalMickeyLang.g:338:1: ruleMigrationBlock : ( ( rule__MigrationBlock__Group__0 ) ) ;
    public final void ruleMigrationBlock() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:342:2: ( ( ( rule__MigrationBlock__Group__0 ) ) )
            // InternalMickeyLang.g:343:2: ( ( rule__MigrationBlock__Group__0 ) )
            {
            // InternalMickeyLang.g:343:2: ( ( rule__MigrationBlock__Group__0 ) )
            // InternalMickeyLang.g:344:3: ( rule__MigrationBlock__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getGroup()); 
            }
            // InternalMickeyLang.g:345:3: ( rule__MigrationBlock__Group__0 )
            // InternalMickeyLang.g:345:4: rule__MigrationBlock__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMigrationBlock"


    // $ANTLR start "entryRuleSqlExpression"
    // InternalMickeyLang.g:354:1: entryRuleSqlExpression : ruleSqlExpression EOF ;
    public final void entryRuleSqlExpression() throws RecognitionException {
        try {
            // InternalMickeyLang.g:355:1: ( ruleSqlExpression EOF )
            // InternalMickeyLang.g:356:1: ruleSqlExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSqlExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSqlExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSqlExpression"


    // $ANTLR start "ruleSqlExpression"
    // InternalMickeyLang.g:363:1: ruleSqlExpression : ( ruleExprConcat ) ;
    public final void ruleSqlExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:367:2: ( ( ruleExprConcat ) )
            // InternalMickeyLang.g:368:2: ( ruleExprConcat )
            {
            // InternalMickeyLang.g:368:2: ( ruleExprConcat )
            // InternalMickeyLang.g:369:3: ruleExprConcat
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSqlExpressionAccess().getExprConcatParserRuleCall()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprConcat();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSqlExpressionAccess().getExprConcatParserRuleCall()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSqlExpression"


    // $ANTLR start "entryRuleExprConcat"
    // InternalMickeyLang.g:379:1: entryRuleExprConcat : ruleExprConcat EOF ;
    public final void entryRuleExprConcat() throws RecognitionException {
        try {
            // InternalMickeyLang.g:380:1: ( ruleExprConcat EOF )
            // InternalMickeyLang.g:381:1: ruleExprConcat EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprConcat();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprConcat"


    // $ANTLR start "ruleExprConcat"
    // InternalMickeyLang.g:388:1: ruleExprConcat : ( ( rule__ExprConcat__Group__0 ) ) ;
    public final void ruleExprConcat() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:392:2: ( ( ( rule__ExprConcat__Group__0 ) ) )
            // InternalMickeyLang.g:393:2: ( ( rule__ExprConcat__Group__0 ) )
            {
            // InternalMickeyLang.g:393:2: ( ( rule__ExprConcat__Group__0 ) )
            // InternalMickeyLang.g:394:3: ( rule__ExprConcat__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getGroup()); 
            }
            // InternalMickeyLang.g:395:3: ( rule__ExprConcat__Group__0 )
            // InternalMickeyLang.g:395:4: rule__ExprConcat__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprConcat__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprConcat"


    // $ANTLR start "entryRuleExprMult"
    // InternalMickeyLang.g:404:1: entryRuleExprMult : ruleExprMult EOF ;
    public final void entryRuleExprMult() throws RecognitionException {
        try {
            // InternalMickeyLang.g:405:1: ( ruleExprMult EOF )
            // InternalMickeyLang.g:406:1: ruleExprMult EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprMult();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprMult"


    // $ANTLR start "ruleExprMult"
    // InternalMickeyLang.g:413:1: ruleExprMult : ( ( rule__ExprMult__Group__0 ) ) ;
    public final void ruleExprMult() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:417:2: ( ( ( rule__ExprMult__Group__0 ) ) )
            // InternalMickeyLang.g:418:2: ( ( rule__ExprMult__Group__0 ) )
            {
            // InternalMickeyLang.g:418:2: ( ( rule__ExprMult__Group__0 ) )
            // InternalMickeyLang.g:419:3: ( rule__ExprMult__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getGroup()); 
            }
            // InternalMickeyLang.g:420:3: ( rule__ExprMult__Group__0 )
            // InternalMickeyLang.g:420:4: rule__ExprMult__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprMult__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprMult"


    // $ANTLR start "entryRuleExprAdd"
    // InternalMickeyLang.g:429:1: entryRuleExprAdd : ruleExprAdd EOF ;
    public final void entryRuleExprAdd() throws RecognitionException {
        try {
            // InternalMickeyLang.g:430:1: ( ruleExprAdd EOF )
            // InternalMickeyLang.g:431:1: ruleExprAdd EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprAdd();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprAdd"


    // $ANTLR start "ruleExprAdd"
    // InternalMickeyLang.g:438:1: ruleExprAdd : ( ( rule__ExprAdd__Group__0 ) ) ;
    public final void ruleExprAdd() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:442:2: ( ( ( rule__ExprAdd__Group__0 ) ) )
            // InternalMickeyLang.g:443:2: ( ( rule__ExprAdd__Group__0 ) )
            {
            // InternalMickeyLang.g:443:2: ( ( rule__ExprAdd__Group__0 ) )
            // InternalMickeyLang.g:444:3: ( rule__ExprAdd__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getGroup()); 
            }
            // InternalMickeyLang.g:445:3: ( rule__ExprAdd__Group__0 )
            // InternalMickeyLang.g:445:4: rule__ExprAdd__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprAdd__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprAdd"


    // $ANTLR start "entryRuleExprBit"
    // InternalMickeyLang.g:454:1: entryRuleExprBit : ruleExprBit EOF ;
    public final void entryRuleExprBit() throws RecognitionException {
        try {
            // InternalMickeyLang.g:455:1: ( ruleExprBit EOF )
            // InternalMickeyLang.g:456:1: ruleExprBit EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprBit();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprBit"


    // $ANTLR start "ruleExprBit"
    // InternalMickeyLang.g:463:1: ruleExprBit : ( ( rule__ExprBit__Group__0 ) ) ;
    public final void ruleExprBit() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:467:2: ( ( ( rule__ExprBit__Group__0 ) ) )
            // InternalMickeyLang.g:468:2: ( ( rule__ExprBit__Group__0 ) )
            {
            // InternalMickeyLang.g:468:2: ( ( rule__ExprBit__Group__0 ) )
            // InternalMickeyLang.g:469:3: ( rule__ExprBit__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getGroup()); 
            }
            // InternalMickeyLang.g:470:3: ( rule__ExprBit__Group__0 )
            // InternalMickeyLang.g:470:4: rule__ExprBit__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprBit__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprBit"


    // $ANTLR start "entryRuleExprRelate"
    // InternalMickeyLang.g:479:1: entryRuleExprRelate : ruleExprRelate EOF ;
    public final void entryRuleExprRelate() throws RecognitionException {
        try {
            // InternalMickeyLang.g:480:1: ( ruleExprRelate EOF )
            // InternalMickeyLang.g:481:1: ruleExprRelate EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprRelate();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprRelate"


    // $ANTLR start "ruleExprRelate"
    // InternalMickeyLang.g:488:1: ruleExprRelate : ( ( rule__ExprRelate__Group__0 ) ) ;
    public final void ruleExprRelate() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:492:2: ( ( ( rule__ExprRelate__Group__0 ) ) )
            // InternalMickeyLang.g:493:2: ( ( rule__ExprRelate__Group__0 ) )
            {
            // InternalMickeyLang.g:493:2: ( ( rule__ExprRelate__Group__0 ) )
            // InternalMickeyLang.g:494:3: ( rule__ExprRelate__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getGroup()); 
            }
            // InternalMickeyLang.g:495:3: ( rule__ExprRelate__Group__0 )
            // InternalMickeyLang.g:495:4: rule__ExprRelate__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprRelate__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprRelate"


    // $ANTLR start "entryRuleExprEqual"
    // InternalMickeyLang.g:504:1: entryRuleExprEqual : ruleExprEqual EOF ;
    public final void entryRuleExprEqual() throws RecognitionException {
        try {
            // InternalMickeyLang.g:505:1: ( ruleExprEqual EOF )
            // InternalMickeyLang.g:506:1: ruleExprEqual EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprEqual();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprEqual"


    // $ANTLR start "ruleExprEqual"
    // InternalMickeyLang.g:513:1: ruleExprEqual : ( ( rule__ExprEqual__Group__0 ) ) ;
    public final void ruleExprEqual() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:517:2: ( ( ( rule__ExprEqual__Group__0 ) ) )
            // InternalMickeyLang.g:518:2: ( ( rule__ExprEqual__Group__0 ) )
            {
            // InternalMickeyLang.g:518:2: ( ( rule__ExprEqual__Group__0 ) )
            // InternalMickeyLang.g:519:3: ( rule__ExprEqual__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getGroup()); 
            }
            // InternalMickeyLang.g:520:3: ( rule__ExprEqual__Group__0 )
            // InternalMickeyLang.g:520:4: rule__ExprEqual__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprEqual__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprEqual"


    // $ANTLR start "entryRuleExprAnd"
    // InternalMickeyLang.g:529:1: entryRuleExprAnd : ruleExprAnd EOF ;
    public final void entryRuleExprAnd() throws RecognitionException {
        try {
            // InternalMickeyLang.g:530:1: ( ruleExprAnd EOF )
            // InternalMickeyLang.g:531:1: ruleExprAnd EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprAnd();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprAnd"


    // $ANTLR start "ruleExprAnd"
    // InternalMickeyLang.g:538:1: ruleExprAnd : ( ( rule__ExprAnd__Group__0 ) ) ;
    public final void ruleExprAnd() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:542:2: ( ( ( rule__ExprAnd__Group__0 ) ) )
            // InternalMickeyLang.g:543:2: ( ( rule__ExprAnd__Group__0 ) )
            {
            // InternalMickeyLang.g:543:2: ( ( rule__ExprAnd__Group__0 ) )
            // InternalMickeyLang.g:544:3: ( rule__ExprAnd__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getGroup()); 
            }
            // InternalMickeyLang.g:545:3: ( rule__ExprAnd__Group__0 )
            // InternalMickeyLang.g:545:4: rule__ExprAnd__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprAnd__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprAnd"


    // $ANTLR start "entryRuleExprOr"
    // InternalMickeyLang.g:554:1: entryRuleExprOr : ruleExprOr EOF ;
    public final void entryRuleExprOr() throws RecognitionException {
        try {
            // InternalMickeyLang.g:555:1: ( ruleExprOr EOF )
            // InternalMickeyLang.g:556:1: ruleExprOr EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExprOr();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExprOr"


    // $ANTLR start "ruleExprOr"
    // InternalMickeyLang.g:563:1: ruleExprOr : ( ( rule__ExprOr__Group__0 ) ) ;
    public final void ruleExprOr() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:567:2: ( ( ( rule__ExprOr__Group__0 ) ) )
            // InternalMickeyLang.g:568:2: ( ( rule__ExprOr__Group__0 ) )
            {
            // InternalMickeyLang.g:568:2: ( ( rule__ExprOr__Group__0 ) )
            // InternalMickeyLang.g:569:3: ( rule__ExprOr__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getGroup()); 
            }
            // InternalMickeyLang.g:570:3: ( rule__ExprOr__Group__0 )
            // InternalMickeyLang.g:570:4: rule__ExprOr__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExprOr__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExprOr"


    // $ANTLR start "entryRuleNullCheckExpression"
    // InternalMickeyLang.g:579:1: entryRuleNullCheckExpression : ruleNullCheckExpression EOF ;
    public final void entryRuleNullCheckExpression() throws RecognitionException {
        try {
            // InternalMickeyLang.g:580:1: ( ruleNullCheckExpression EOF )
            // InternalMickeyLang.g:581:1: ruleNullCheckExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNullCheckExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNullCheckExpression"


    // $ANTLR start "ruleNullCheckExpression"
    // InternalMickeyLang.g:588:1: ruleNullCheckExpression : ( ( rule__NullCheckExpression__Group__0 ) ) ;
    public final void ruleNullCheckExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:592:2: ( ( ( rule__NullCheckExpression__Group__0 ) ) )
            // InternalMickeyLang.g:593:2: ( ( rule__NullCheckExpression__Group__0 ) )
            {
            // InternalMickeyLang.g:593:2: ( ( rule__NullCheckExpression__Group__0 ) )
            // InternalMickeyLang.g:594:3: ( rule__NullCheckExpression__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionAccess().getGroup()); 
            }
            // InternalMickeyLang.g:595:3: ( rule__NullCheckExpression__Group__0 )
            // InternalMickeyLang.g:595:4: rule__NullCheckExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__NullCheckExpression__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNullCheckExpression"


    // $ANTLR start "entryRuleNullExpression"
    // InternalMickeyLang.g:604:1: entryRuleNullExpression : ruleNullExpression EOF ;
    public final void entryRuleNullExpression() throws RecognitionException {
        try {
            // InternalMickeyLang.g:605:1: ( ruleNullExpression EOF )
            // InternalMickeyLang.g:606:1: ruleNullExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNullExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNullExpression"


    // $ANTLR start "ruleNullExpression"
    // InternalMickeyLang.g:613:1: ruleNullExpression : ( ( rule__NullExpression__Alternatives ) ) ;
    public final void ruleNullExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:617:2: ( ( ( rule__NullExpression__Alternatives ) ) )
            // InternalMickeyLang.g:618:2: ( ( rule__NullExpression__Alternatives ) )
            {
            // InternalMickeyLang.g:618:2: ( ( rule__NullExpression__Alternatives ) )
            // InternalMickeyLang.g:619:3: ( rule__NullExpression__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullExpressionAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:620:3: ( rule__NullExpression__Alternatives )
            // InternalMickeyLang.g:620:4: rule__NullExpression__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__NullExpression__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullExpressionAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNullExpression"


    // $ANTLR start "entryRulePrimaryExpression"
    // InternalMickeyLang.g:629:1: entryRulePrimaryExpression : rulePrimaryExpression EOF ;
    public final void entryRulePrimaryExpression() throws RecognitionException {
        try {
            // InternalMickeyLang.g:630:1: ( rulePrimaryExpression EOF )
            // InternalMickeyLang.g:631:1: rulePrimaryExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrimaryExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrimaryExpression"


    // $ANTLR start "rulePrimaryExpression"
    // InternalMickeyLang.g:638:1: rulePrimaryExpression : ( ( rule__PrimaryExpression__Alternatives ) ) ;
    public final void rulePrimaryExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:642:2: ( ( ( rule__PrimaryExpression__Alternatives ) ) )
            // InternalMickeyLang.g:643:2: ( ( rule__PrimaryExpression__Alternatives ) )
            {
            // InternalMickeyLang.g:643:2: ( ( rule__PrimaryExpression__Alternatives ) )
            // InternalMickeyLang.g:644:3: ( rule__PrimaryExpression__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:645:3: ( rule__PrimaryExpression__Alternatives )
            // InternalMickeyLang.g:645:4: rule__PrimaryExpression__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrimaryExpression"


    // $ANTLR start "entryRuleCase"
    // InternalMickeyLang.g:654:1: entryRuleCase : ruleCase EOF ;
    public final void entryRuleCase() throws RecognitionException {
        try {
            // InternalMickeyLang.g:655:1: ( ruleCase EOF )
            // InternalMickeyLang.g:656:1: ruleCase EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCase();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCase"


    // $ANTLR start "ruleCase"
    // InternalMickeyLang.g:663:1: ruleCase : ( ( rule__Case__Group__0 ) ) ;
    public final void ruleCase() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:667:2: ( ( ( rule__Case__Group__0 ) ) )
            // InternalMickeyLang.g:668:2: ( ( rule__Case__Group__0 ) )
            {
            // InternalMickeyLang.g:668:2: ( ( rule__Case__Group__0 ) )
            // InternalMickeyLang.g:669:3: ( rule__Case__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getGroup()); 
            }
            // InternalMickeyLang.g:670:3: ( rule__Case__Group__0 )
            // InternalMickeyLang.g:670:4: rule__Case__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Case__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCase"


    // $ANTLR start "entryRuleSelectStatement"
    // InternalMickeyLang.g:679:1: entryRuleSelectStatement : ruleSelectStatement EOF ;
    public final void entryRuleSelectStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:680:1: ( ruleSelectStatement EOF )
            // InternalMickeyLang.g:681:1: ruleSelectStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSelectStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSelectStatement"


    // $ANTLR start "ruleSelectStatement"
    // InternalMickeyLang.g:688:1: ruleSelectStatement : ( ( rule__SelectStatement__Group__0 ) ) ;
    public final void ruleSelectStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:692:2: ( ( ( rule__SelectStatement__Group__0 ) ) )
            // InternalMickeyLang.g:693:2: ( ( rule__SelectStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:693:2: ( ( rule__SelectStatement__Group__0 ) )
            // InternalMickeyLang.g:694:3: ( rule__SelectStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:695:3: ( rule__SelectStatement__Group__0 )
            // InternalMickeyLang.g:695:4: rule__SelectStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSelectStatement"


    // $ANTLR start "entryRuleOrderingTermList"
    // InternalMickeyLang.g:704:1: entryRuleOrderingTermList : ruleOrderingTermList EOF ;
    public final void entryRuleOrderingTermList() throws RecognitionException {
        try {
            // InternalMickeyLang.g:705:1: ( ruleOrderingTermList EOF )
            // InternalMickeyLang.g:706:1: ruleOrderingTermList EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOrderingTermList();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleOrderingTermList"


    // $ANTLR start "ruleOrderingTermList"
    // InternalMickeyLang.g:713:1: ruleOrderingTermList : ( ( rule__OrderingTermList__Group__0 ) ) ;
    public final void ruleOrderingTermList() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:717:2: ( ( ( rule__OrderingTermList__Group__0 ) ) )
            // InternalMickeyLang.g:718:2: ( ( rule__OrderingTermList__Group__0 ) )
            {
            // InternalMickeyLang.g:718:2: ( ( rule__OrderingTermList__Group__0 ) )
            // InternalMickeyLang.g:719:3: ( rule__OrderingTermList__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getGroup()); 
            }
            // InternalMickeyLang.g:720:3: ( rule__OrderingTermList__Group__0 )
            // InternalMickeyLang.g:720:4: rule__OrderingTermList__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleOrderingTermList"


    // $ANTLR start "entryRuleSelectCore"
    // InternalMickeyLang.g:729:1: entryRuleSelectCore : ruleSelectCore EOF ;
    public final void entryRuleSelectCore() throws RecognitionException {
        try {
            // InternalMickeyLang.g:730:1: ( ruleSelectCore EOF )
            // InternalMickeyLang.g:731:1: ruleSelectCore EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSelectCore();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSelectCore"


    // $ANTLR start "ruleSelectCore"
    // InternalMickeyLang.g:738:1: ruleSelectCore : ( ( rule__SelectCore__Group__0 ) ) ;
    public final void ruleSelectCore() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:742:2: ( ( ( rule__SelectCore__Group__0 ) ) )
            // InternalMickeyLang.g:743:2: ( ( rule__SelectCore__Group__0 ) )
            {
            // InternalMickeyLang.g:743:2: ( ( rule__SelectCore__Group__0 ) )
            // InternalMickeyLang.g:744:3: ( rule__SelectCore__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getGroup()); 
            }
            // InternalMickeyLang.g:745:3: ( rule__SelectCore__Group__0 )
            // InternalMickeyLang.g:745:4: rule__SelectCore__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SelectCore__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSelectCore"


    // $ANTLR start "entryRuleSelectExpression"
    // InternalMickeyLang.g:754:1: entryRuleSelectExpression : ruleSelectExpression EOF ;
    public final void entryRuleSelectExpression() throws RecognitionException {
        try {
            // InternalMickeyLang.g:755:1: ( ruleSelectExpression EOF )
            // InternalMickeyLang.g:756:1: ruleSelectExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSelectExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSelectExpression"


    // $ANTLR start "ruleSelectExpression"
    // InternalMickeyLang.g:763:1: ruleSelectExpression : ( ( rule__SelectExpression__Group__0 ) ) ;
    public final void ruleSelectExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:767:2: ( ( ( rule__SelectExpression__Group__0 ) ) )
            // InternalMickeyLang.g:768:2: ( ( rule__SelectExpression__Group__0 ) )
            {
            // InternalMickeyLang.g:768:2: ( ( rule__SelectExpression__Group__0 ) )
            // InternalMickeyLang.g:769:3: ( rule__SelectExpression__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroup()); 
            }
            // InternalMickeyLang.g:770:3: ( rule__SelectExpression__Group__0 )
            // InternalMickeyLang.g:770:4: rule__SelectExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSelectExpression"


    // $ANTLR start "entryRuleSelectList"
    // InternalMickeyLang.g:779:1: entryRuleSelectList : ruleSelectList EOF ;
    public final void entryRuleSelectList() throws RecognitionException {
        try {
            // InternalMickeyLang.g:780:1: ( ruleSelectList EOF )
            // InternalMickeyLang.g:781:1: ruleSelectList EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSelectList();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSelectList"


    // $ANTLR start "ruleSelectList"
    // InternalMickeyLang.g:788:1: ruleSelectList : ( ( rule__SelectList__Group__0 ) ) ;
    public final void ruleSelectList() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:792:2: ( ( ( rule__SelectList__Group__0 ) ) )
            // InternalMickeyLang.g:793:2: ( ( rule__SelectList__Group__0 ) )
            {
            // InternalMickeyLang.g:793:2: ( ( rule__SelectList__Group__0 ) )
            // InternalMickeyLang.g:794:3: ( rule__SelectList__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getGroup()); 
            }
            // InternalMickeyLang.g:795:3: ( rule__SelectList__Group__0 )
            // InternalMickeyLang.g:795:4: rule__SelectList__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SelectList__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSelectList"


    // $ANTLR start "entryRuleWhereExpressions"
    // InternalMickeyLang.g:804:1: entryRuleWhereExpressions : ruleWhereExpressions EOF ;
    public final void entryRuleWhereExpressions() throws RecognitionException {
        try {
            // InternalMickeyLang.g:805:1: ( ruleWhereExpressions EOF )
            // InternalMickeyLang.g:806:1: ruleWhereExpressions EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWhereExpressionsRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleWhereExpressions();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWhereExpressionsRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleWhereExpressions"


    // $ANTLR start "ruleWhereExpressions"
    // InternalMickeyLang.g:813:1: ruleWhereExpressions : ( ( rule__WhereExpressions__ExpressionAssignment ) ) ;
    public final void ruleWhereExpressions() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:817:2: ( ( ( rule__WhereExpressions__ExpressionAssignment ) ) )
            // InternalMickeyLang.g:818:2: ( ( rule__WhereExpressions__ExpressionAssignment ) )
            {
            // InternalMickeyLang.g:818:2: ( ( rule__WhereExpressions__ExpressionAssignment ) )
            // InternalMickeyLang.g:819:3: ( rule__WhereExpressions__ExpressionAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWhereExpressionsAccess().getExpressionAssignment()); 
            }
            // InternalMickeyLang.g:820:3: ( rule__WhereExpressions__ExpressionAssignment )
            // InternalMickeyLang.g:820:4: rule__WhereExpressions__ExpressionAssignment
            {
            pushFollow(FOLLOW_2);
            rule__WhereExpressions__ExpressionAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWhereExpressionsAccess().getExpressionAssignment()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleWhereExpressions"


    // $ANTLR start "entryRuleGroupByExpressions"
    // InternalMickeyLang.g:829:1: entryRuleGroupByExpressions : ruleGroupByExpressions EOF ;
    public final void entryRuleGroupByExpressions() throws RecognitionException {
        try {
            // InternalMickeyLang.g:830:1: ( ruleGroupByExpressions EOF )
            // InternalMickeyLang.g:831:1: ruleGroupByExpressions EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleGroupByExpressions();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleGroupByExpressions"


    // $ANTLR start "ruleGroupByExpressions"
    // InternalMickeyLang.g:838:1: ruleGroupByExpressions : ( ( rule__GroupByExpressions__Group__0 ) ) ;
    public final void ruleGroupByExpressions() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:842:2: ( ( ( rule__GroupByExpressions__Group__0 ) ) )
            // InternalMickeyLang.g:843:2: ( ( rule__GroupByExpressions__Group__0 ) )
            {
            // InternalMickeyLang.g:843:2: ( ( rule__GroupByExpressions__Group__0 ) )
            // InternalMickeyLang.g:844:3: ( rule__GroupByExpressions__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getGroup()); 
            }
            // InternalMickeyLang.g:845:3: ( rule__GroupByExpressions__Group__0 )
            // InternalMickeyLang.g:845:4: rule__GroupByExpressions__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleGroupByExpressions"


    // $ANTLR start "entryRuleHavingExpressions"
    // InternalMickeyLang.g:854:1: entryRuleHavingExpressions : ruleHavingExpressions EOF ;
    public final void entryRuleHavingExpressions() throws RecognitionException {
        try {
            // InternalMickeyLang.g:855:1: ( ruleHavingExpressions EOF )
            // InternalMickeyLang.g:856:1: ruleHavingExpressions EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getHavingExpressionsRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleHavingExpressions();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getHavingExpressionsRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleHavingExpressions"


    // $ANTLR start "ruleHavingExpressions"
    // InternalMickeyLang.g:863:1: ruleHavingExpressions : ( ( rule__HavingExpressions__ExpressionAssignment ) ) ;
    public final void ruleHavingExpressions() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:867:2: ( ( ( rule__HavingExpressions__ExpressionAssignment ) ) )
            // InternalMickeyLang.g:868:2: ( ( rule__HavingExpressions__ExpressionAssignment ) )
            {
            // InternalMickeyLang.g:868:2: ( ( rule__HavingExpressions__ExpressionAssignment ) )
            // InternalMickeyLang.g:869:3: ( rule__HavingExpressions__ExpressionAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getHavingExpressionsAccess().getExpressionAssignment()); 
            }
            // InternalMickeyLang.g:870:3: ( rule__HavingExpressions__ExpressionAssignment )
            // InternalMickeyLang.g:870:4: rule__HavingExpressions__ExpressionAssignment
            {
            pushFollow(FOLLOW_2);
            rule__HavingExpressions__ExpressionAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getHavingExpressionsAccess().getExpressionAssignment()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleHavingExpressions"


    // $ANTLR start "entryRuleOrderingTerm"
    // InternalMickeyLang.g:879:1: entryRuleOrderingTerm : ruleOrderingTerm EOF ;
    public final void entryRuleOrderingTerm() throws RecognitionException {
        try {
            // InternalMickeyLang.g:880:1: ( ruleOrderingTerm EOF )
            // InternalMickeyLang.g:881:1: ruleOrderingTerm EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOrderingTerm();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleOrderingTerm"


    // $ANTLR start "ruleOrderingTerm"
    // InternalMickeyLang.g:888:1: ruleOrderingTerm : ( ( rule__OrderingTerm__Group__0 ) ) ;
    public final void ruleOrderingTerm() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:892:2: ( ( ( rule__OrderingTerm__Group__0 ) ) )
            // InternalMickeyLang.g:893:2: ( ( rule__OrderingTerm__Group__0 ) )
            {
            // InternalMickeyLang.g:893:2: ( ( rule__OrderingTerm__Group__0 ) )
            // InternalMickeyLang.g:894:3: ( rule__OrderingTerm__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getGroup()); 
            }
            // InternalMickeyLang.g:895:3: ( rule__OrderingTerm__Group__0 )
            // InternalMickeyLang.g:895:4: rule__OrderingTerm__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTerm__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleOrderingTerm"


    // $ANTLR start "entryRuleJoinSource"
    // InternalMickeyLang.g:904:1: entryRuleJoinSource : ruleJoinSource EOF ;
    public final void entryRuleJoinSource() throws RecognitionException {
        try {
            // InternalMickeyLang.g:905:1: ( ruleJoinSource EOF )
            // InternalMickeyLang.g:906:1: ruleJoinSource EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinSourceRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleJoinSource();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinSourceRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleJoinSource"


    // $ANTLR start "ruleJoinSource"
    // InternalMickeyLang.g:913:1: ruleJoinSource : ( ( rule__JoinSource__Group__0 ) ) ;
    public final void ruleJoinSource() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:917:2: ( ( ( rule__JoinSource__Group__0 ) ) )
            // InternalMickeyLang.g:918:2: ( ( rule__JoinSource__Group__0 ) )
            {
            // InternalMickeyLang.g:918:2: ( ( rule__JoinSource__Group__0 ) )
            // InternalMickeyLang.g:919:3: ( rule__JoinSource__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinSourceAccess().getGroup()); 
            }
            // InternalMickeyLang.g:920:3: ( rule__JoinSource__Group__0 )
            // InternalMickeyLang.g:920:4: rule__JoinSource__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__JoinSource__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinSourceAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleJoinSource"


    // $ANTLR start "entryRuleSingleSource"
    // InternalMickeyLang.g:929:1: entryRuleSingleSource : ruleSingleSource EOF ;
    public final void entryRuleSingleSource() throws RecognitionException {
        try {
            // InternalMickeyLang.g:930:1: ( ruleSingleSource EOF )
            // InternalMickeyLang.g:931:1: ruleSingleSource EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSingleSource();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSingleSource"


    // $ANTLR start "ruleSingleSource"
    // InternalMickeyLang.g:938:1: ruleSingleSource : ( ( rule__SingleSource__Alternatives ) ) ;
    public final void ruleSingleSource() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:942:2: ( ( ( rule__SingleSource__Alternatives ) ) )
            // InternalMickeyLang.g:943:2: ( ( rule__SingleSource__Alternatives ) )
            {
            // InternalMickeyLang.g:943:2: ( ( rule__SingleSource__Alternatives ) )
            // InternalMickeyLang.g:944:3: ( rule__SingleSource__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:945:3: ( rule__SingleSource__Alternatives )
            // InternalMickeyLang.g:945:4: rule__SingleSource__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__SingleSource__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSingleSource"


    // $ANTLR start "entryRuleSingleSourceTable"
    // InternalMickeyLang.g:954:1: entryRuleSingleSourceTable : ruleSingleSourceTable EOF ;
    public final void entryRuleSingleSourceTable() throws RecognitionException {
        try {
            // InternalMickeyLang.g:955:1: ( ruleSingleSourceTable EOF )
            // InternalMickeyLang.g:956:1: ruleSingleSourceTable EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSingleSourceTable();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSingleSourceTable"


    // $ANTLR start "ruleSingleSourceTable"
    // InternalMickeyLang.g:963:1: ruleSingleSourceTable : ( ( rule__SingleSourceTable__Group__0 ) ) ;
    public final void ruleSingleSourceTable() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:967:2: ( ( ( rule__SingleSourceTable__Group__0 ) ) )
            // InternalMickeyLang.g:968:2: ( ( rule__SingleSourceTable__Group__0 ) )
            {
            // InternalMickeyLang.g:968:2: ( ( rule__SingleSourceTable__Group__0 ) )
            // InternalMickeyLang.g:969:3: ( rule__SingleSourceTable__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getGroup()); 
            }
            // InternalMickeyLang.g:970:3: ( rule__SingleSourceTable__Group__0 )
            // InternalMickeyLang.g:970:4: rule__SingleSourceTable__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSingleSourceTable"


    // $ANTLR start "entryRuleSingleSourceSelectStatement"
    // InternalMickeyLang.g:979:1: entryRuleSingleSourceSelectStatement : ruleSingleSourceSelectStatement EOF ;
    public final void entryRuleSingleSourceSelectStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:980:1: ( ruleSingleSourceSelectStatement EOF )
            // InternalMickeyLang.g:981:1: ruleSingleSourceSelectStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSingleSourceSelectStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSingleSourceSelectStatement"


    // $ANTLR start "ruleSingleSourceSelectStatement"
    // InternalMickeyLang.g:988:1: ruleSingleSourceSelectStatement : ( ( rule__SingleSourceSelectStatement__Group__0 ) ) ;
    public final void ruleSingleSourceSelectStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:992:2: ( ( ( rule__SingleSourceSelectStatement__Group__0 ) ) )
            // InternalMickeyLang.g:993:2: ( ( rule__SingleSourceSelectStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:993:2: ( ( rule__SingleSourceSelectStatement__Group__0 ) )
            // InternalMickeyLang.g:994:3: ( rule__SingleSourceSelectStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:995:3: ( rule__SingleSourceSelectStatement__Group__0 )
            // InternalMickeyLang.g:995:4: rule__SingleSourceSelectStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSingleSourceSelectStatement"


    // $ANTLR start "entryRuleSingleSourceJoin"
    // InternalMickeyLang.g:1004:1: entryRuleSingleSourceJoin : ruleSingleSourceJoin EOF ;
    public final void entryRuleSingleSourceJoin() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1005:1: ( ruleSingleSourceJoin EOF )
            // InternalMickeyLang.g:1006:1: ruleSingleSourceJoin EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceJoinRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSingleSourceJoin();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceJoinRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSingleSourceJoin"


    // $ANTLR start "ruleSingleSourceJoin"
    // InternalMickeyLang.g:1013:1: ruleSingleSourceJoin : ( ( rule__SingleSourceJoin__Group__0 ) ) ;
    public final void ruleSingleSourceJoin() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1017:2: ( ( ( rule__SingleSourceJoin__Group__0 ) ) )
            // InternalMickeyLang.g:1018:2: ( ( rule__SingleSourceJoin__Group__0 ) )
            {
            // InternalMickeyLang.g:1018:2: ( ( rule__SingleSourceJoin__Group__0 ) )
            // InternalMickeyLang.g:1019:3: ( rule__SingleSourceJoin__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceJoinAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1020:3: ( rule__SingleSourceJoin__Group__0 )
            // InternalMickeyLang.g:1020:4: rule__SingleSourceJoin__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceJoin__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceJoinAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSingleSourceJoin"


    // $ANTLR start "entryRuleJoinStatement"
    // InternalMickeyLang.g:1029:1: entryRuleJoinStatement : ruleJoinStatement EOF ;
    public final void entryRuleJoinStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1030:1: ( ruleJoinStatement EOF )
            // InternalMickeyLang.g:1031:1: ruleJoinStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleJoinStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleJoinStatement"


    // $ANTLR start "ruleJoinStatement"
    // InternalMickeyLang.g:1038:1: ruleJoinStatement : ( ( rule__JoinStatement__Group__0 ) ) ;
    public final void ruleJoinStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1042:2: ( ( ( rule__JoinStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1043:2: ( ( rule__JoinStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1043:2: ( ( rule__JoinStatement__Group__0 ) )
            // InternalMickeyLang.g:1044:3: ( rule__JoinStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1045:3: ( rule__JoinStatement__Group__0 )
            // InternalMickeyLang.g:1045:4: rule__JoinStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleJoinStatement"


    // $ANTLR start "entryRuleResultColumn"
    // InternalMickeyLang.g:1054:1: entryRuleResultColumn : ruleResultColumn EOF ;
    public final void entryRuleResultColumn() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1055:1: ( ruleResultColumn EOF )
            // InternalMickeyLang.g:1056:1: ruleResultColumn EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleResultColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleResultColumn"


    // $ANTLR start "ruleResultColumn"
    // InternalMickeyLang.g:1063:1: ruleResultColumn : ( ( rule__ResultColumn__Group__0 ) ) ;
    public final void ruleResultColumn() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1067:2: ( ( ( rule__ResultColumn__Group__0 ) ) )
            // InternalMickeyLang.g:1068:2: ( ( rule__ResultColumn__Group__0 ) )
            {
            // InternalMickeyLang.g:1068:2: ( ( rule__ResultColumn__Group__0 ) )
            // InternalMickeyLang.g:1069:3: ( rule__ResultColumn__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1070:3: ( rule__ResultColumn__Group__0 )
            // InternalMickeyLang.g:1070:4: rule__ResultColumn__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ResultColumn__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleResultColumn"


    // $ANTLR start "entryRuleLiteralValue"
    // InternalMickeyLang.g:1079:1: entryRuleLiteralValue : ruleLiteralValue EOF ;
    public final void entryRuleLiteralValue() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1080:1: ( ruleLiteralValue EOF )
            // InternalMickeyLang.g:1081:1: ruleLiteralValue EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLiteralValue();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleLiteralValue"


    // $ANTLR start "ruleLiteralValue"
    // InternalMickeyLang.g:1088:1: ruleLiteralValue : ( ( rule__LiteralValue__Alternatives ) ) ;
    public final void ruleLiteralValue() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1092:2: ( ( ( rule__LiteralValue__Alternatives ) ) )
            // InternalMickeyLang.g:1093:2: ( ( rule__LiteralValue__Alternatives ) )
            {
            // InternalMickeyLang.g:1093:2: ( ( rule__LiteralValue__Alternatives ) )
            // InternalMickeyLang.g:1094:3: ( rule__LiteralValue__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1095:3: ( rule__LiteralValue__Alternatives )
            // InternalMickeyLang.g:1095:4: rule__LiteralValue__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleLiteralValue"


    // $ANTLR start "entryRuleDDLStatement"
    // InternalMickeyLang.g:1104:1: entryRuleDDLStatement : ruleDDLStatement EOF ;
    public final void entryRuleDDLStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1105:1: ( ruleDDLStatement EOF )
            // InternalMickeyLang.g:1106:1: ruleDDLStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDDLStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDDLStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDDLStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDDLStatement"


    // $ANTLR start "ruleDDLStatement"
    // InternalMickeyLang.g:1113:1: ruleDDLStatement : ( ( rule__DDLStatement__Alternatives ) ) ;
    public final void ruleDDLStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1117:2: ( ( ( rule__DDLStatement__Alternatives ) ) )
            // InternalMickeyLang.g:1118:2: ( ( rule__DDLStatement__Alternatives ) )
            {
            // InternalMickeyLang.g:1118:2: ( ( rule__DDLStatement__Alternatives ) )
            // InternalMickeyLang.g:1119:3: ( rule__DDLStatement__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDDLStatementAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1120:3: ( rule__DDLStatement__Alternatives )
            // InternalMickeyLang.g:1120:4: rule__DDLStatement__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__DDLStatement__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDDLStatementAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDDLStatement"


    // $ANTLR start "entryRuleCreateTableStatement"
    // InternalMickeyLang.g:1129:1: entryRuleCreateTableStatement : ruleCreateTableStatement EOF ;
    public final void entryRuleCreateTableStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1130:1: ( ruleCreateTableStatement EOF )
            // InternalMickeyLang.g:1131:1: ruleCreateTableStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCreateTableStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCreateTableStatement"


    // $ANTLR start "ruleCreateTableStatement"
    // InternalMickeyLang.g:1138:1: ruleCreateTableStatement : ( ( rule__CreateTableStatement__Group__0 ) ) ;
    public final void ruleCreateTableStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1142:2: ( ( ( rule__CreateTableStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1143:2: ( ( rule__CreateTableStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1143:2: ( ( rule__CreateTableStatement__Group__0 ) )
            // InternalMickeyLang.g:1144:3: ( rule__CreateTableStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1145:3: ( rule__CreateTableStatement__Group__0 )
            // InternalMickeyLang.g:1145:4: rule__CreateTableStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCreateTableStatement"


    // $ANTLR start "entryRuleCreateViewStatement"
    // InternalMickeyLang.g:1154:1: entryRuleCreateViewStatement : ruleCreateViewStatement EOF ;
    public final void entryRuleCreateViewStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1155:1: ( ruleCreateViewStatement EOF )
            // InternalMickeyLang.g:1156:1: ruleCreateViewStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCreateViewStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCreateViewStatement"


    // $ANTLR start "ruleCreateViewStatement"
    // InternalMickeyLang.g:1163:1: ruleCreateViewStatement : ( ( rule__CreateViewStatement__Group__0 ) ) ;
    public final void ruleCreateViewStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1167:2: ( ( ( rule__CreateViewStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1168:2: ( ( rule__CreateViewStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1168:2: ( ( rule__CreateViewStatement__Group__0 ) )
            // InternalMickeyLang.g:1169:3: ( rule__CreateViewStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1170:3: ( rule__CreateViewStatement__Group__0 )
            // InternalMickeyLang.g:1170:4: rule__CreateViewStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCreateViewStatement"


    // $ANTLR start "entryRuleCreateTriggerStatement"
    // InternalMickeyLang.g:1179:1: entryRuleCreateTriggerStatement : ruleCreateTriggerStatement EOF ;
    public final void entryRuleCreateTriggerStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1180:1: ( ruleCreateTriggerStatement EOF )
            // InternalMickeyLang.g:1181:1: ruleCreateTriggerStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCreateTriggerStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCreateTriggerStatement"


    // $ANTLR start "ruleCreateTriggerStatement"
    // InternalMickeyLang.g:1188:1: ruleCreateTriggerStatement : ( ( rule__CreateTriggerStatement__Group__0 ) ) ;
    public final void ruleCreateTriggerStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1192:2: ( ( ( rule__CreateTriggerStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1193:2: ( ( rule__CreateTriggerStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1193:2: ( ( rule__CreateTriggerStatement__Group__0 ) )
            // InternalMickeyLang.g:1194:3: ( rule__CreateTriggerStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1195:3: ( rule__CreateTriggerStatement__Group__0 )
            // InternalMickeyLang.g:1195:4: rule__CreateTriggerStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCreateTriggerStatement"


    // $ANTLR start "entryRuleAlterTableRenameStatement"
    // InternalMickeyLang.g:1204:1: entryRuleAlterTableRenameStatement : ruleAlterTableRenameStatement EOF ;
    public final void entryRuleAlterTableRenameStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1205:1: ( ruleAlterTableRenameStatement EOF )
            // InternalMickeyLang.g:1206:1: ruleAlterTableRenameStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleAlterTableRenameStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleAlterTableRenameStatement"


    // $ANTLR start "ruleAlterTableRenameStatement"
    // InternalMickeyLang.g:1213:1: ruleAlterTableRenameStatement : ( ( rule__AlterTableRenameStatement__Group__0 ) ) ;
    public final void ruleAlterTableRenameStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1217:2: ( ( ( rule__AlterTableRenameStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1218:2: ( ( rule__AlterTableRenameStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1218:2: ( ( rule__AlterTableRenameStatement__Group__0 ) )
            // InternalMickeyLang.g:1219:3: ( rule__AlterTableRenameStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1220:3: ( rule__AlterTableRenameStatement__Group__0 )
            // InternalMickeyLang.g:1220:4: rule__AlterTableRenameStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleAlterTableRenameStatement"


    // $ANTLR start "entryRuleAlterTableAddColumnStatement"
    // InternalMickeyLang.g:1229:1: entryRuleAlterTableAddColumnStatement : ruleAlterTableAddColumnStatement EOF ;
    public final void entryRuleAlterTableAddColumnStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1230:1: ( ruleAlterTableAddColumnStatement EOF )
            // InternalMickeyLang.g:1231:1: ruleAlterTableAddColumnStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleAlterTableAddColumnStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleAlterTableAddColumnStatement"


    // $ANTLR start "ruleAlterTableAddColumnStatement"
    // InternalMickeyLang.g:1238:1: ruleAlterTableAddColumnStatement : ( ( rule__AlterTableAddColumnStatement__Group__0 ) ) ;
    public final void ruleAlterTableAddColumnStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1242:2: ( ( ( rule__AlterTableAddColumnStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1243:2: ( ( rule__AlterTableAddColumnStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1243:2: ( ( rule__AlterTableAddColumnStatement__Group__0 ) )
            // InternalMickeyLang.g:1244:3: ( rule__AlterTableAddColumnStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1245:3: ( rule__AlterTableAddColumnStatement__Group__0 )
            // InternalMickeyLang.g:1245:4: rule__AlterTableAddColumnStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleAlterTableAddColumnStatement"


    // $ANTLR start "entryRuleDropTableStatement"
    // InternalMickeyLang.g:1254:1: entryRuleDropTableStatement : ruleDropTableStatement EOF ;
    public final void entryRuleDropTableStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1255:1: ( ruleDropTableStatement EOF )
            // InternalMickeyLang.g:1256:1: ruleDropTableStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDropTableStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDropTableStatement"


    // $ANTLR start "ruleDropTableStatement"
    // InternalMickeyLang.g:1263:1: ruleDropTableStatement : ( ( rule__DropTableStatement__Group__0 ) ) ;
    public final void ruleDropTableStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1267:2: ( ( ( rule__DropTableStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1268:2: ( ( rule__DropTableStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1268:2: ( ( rule__DropTableStatement__Group__0 ) )
            // InternalMickeyLang.g:1269:3: ( rule__DropTableStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1270:3: ( rule__DropTableStatement__Group__0 )
            // InternalMickeyLang.g:1270:4: rule__DropTableStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DropTableStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDropTableStatement"


    // $ANTLR start "entryRuleDropTriggerStatement"
    // InternalMickeyLang.g:1279:1: entryRuleDropTriggerStatement : ruleDropTriggerStatement EOF ;
    public final void entryRuleDropTriggerStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1280:1: ( ruleDropTriggerStatement EOF )
            // InternalMickeyLang.g:1281:1: ruleDropTriggerStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDropTriggerStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDropTriggerStatement"


    // $ANTLR start "ruleDropTriggerStatement"
    // InternalMickeyLang.g:1288:1: ruleDropTriggerStatement : ( ( rule__DropTriggerStatement__Group__0 ) ) ;
    public final void ruleDropTriggerStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1292:2: ( ( ( rule__DropTriggerStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1293:2: ( ( rule__DropTriggerStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1293:2: ( ( rule__DropTriggerStatement__Group__0 ) )
            // InternalMickeyLang.g:1294:3: ( rule__DropTriggerStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1295:3: ( rule__DropTriggerStatement__Group__0 )
            // InternalMickeyLang.g:1295:4: rule__DropTriggerStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DropTriggerStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDropTriggerStatement"


    // $ANTLR start "entryRuleDropViewStatement"
    // InternalMickeyLang.g:1304:1: entryRuleDropViewStatement : ruleDropViewStatement EOF ;
    public final void entryRuleDropViewStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1305:1: ( ruleDropViewStatement EOF )
            // InternalMickeyLang.g:1306:1: ruleDropViewStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDropViewStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDropViewStatement"


    // $ANTLR start "ruleDropViewStatement"
    // InternalMickeyLang.g:1313:1: ruleDropViewStatement : ( ( rule__DropViewStatement__Group__0 ) ) ;
    public final void ruleDropViewStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1317:2: ( ( ( rule__DropViewStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1318:2: ( ( rule__DropViewStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1318:2: ( ( rule__DropViewStatement__Group__0 ) )
            // InternalMickeyLang.g:1319:3: ( rule__DropViewStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1320:3: ( rule__DropViewStatement__Group__0 )
            // InternalMickeyLang.g:1320:4: rule__DropViewStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DropViewStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDropViewStatement"


    // $ANTLR start "entryRuleCreateIndexStatement"
    // InternalMickeyLang.g:1329:1: entryRuleCreateIndexStatement : ruleCreateIndexStatement EOF ;
    public final void entryRuleCreateIndexStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1330:1: ( ruleCreateIndexStatement EOF )
            // InternalMickeyLang.g:1331:1: ruleCreateIndexStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCreateIndexStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCreateIndexStatement"


    // $ANTLR start "ruleCreateIndexStatement"
    // InternalMickeyLang.g:1338:1: ruleCreateIndexStatement : ( ( rule__CreateIndexStatement__Group__0 ) ) ;
    public final void ruleCreateIndexStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1342:2: ( ( ( rule__CreateIndexStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1343:2: ( ( rule__CreateIndexStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1343:2: ( ( rule__CreateIndexStatement__Group__0 ) )
            // InternalMickeyLang.g:1344:3: ( rule__CreateIndexStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1345:3: ( rule__CreateIndexStatement__Group__0 )
            // InternalMickeyLang.g:1345:4: rule__CreateIndexStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCreateIndexStatement"


    // $ANTLR start "entryRuleDropIndexStatement"
    // InternalMickeyLang.g:1354:1: entryRuleDropIndexStatement : ruleDropIndexStatement EOF ;
    public final void entryRuleDropIndexStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1355:1: ( ruleDropIndexStatement EOF )
            // InternalMickeyLang.g:1356:1: ruleDropIndexStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDropIndexStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDropIndexStatement"


    // $ANTLR start "ruleDropIndexStatement"
    // InternalMickeyLang.g:1363:1: ruleDropIndexStatement : ( ( rule__DropIndexStatement__Group__0 ) ) ;
    public final void ruleDropIndexStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1367:2: ( ( ( rule__DropIndexStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1368:2: ( ( rule__DropIndexStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1368:2: ( ( rule__DropIndexStatement__Group__0 ) )
            // InternalMickeyLang.g:1369:3: ( rule__DropIndexStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1370:3: ( rule__DropIndexStatement__Group__0 )
            // InternalMickeyLang.g:1370:4: rule__DropIndexStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DropIndexStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDropIndexStatement"


    // $ANTLR start "entryRuleColumnDef"
    // InternalMickeyLang.g:1379:1: entryRuleColumnDef : ruleColumnDef EOF ;
    public final void entryRuleColumnDef() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1380:1: ( ruleColumnDef EOF )
            // InternalMickeyLang.g:1381:1: ruleColumnDef EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleColumnDef();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleColumnDef"


    // $ANTLR start "ruleColumnDef"
    // InternalMickeyLang.g:1388:1: ruleColumnDef : ( ( rule__ColumnDef__Group__0 ) ) ;
    public final void ruleColumnDef() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1392:2: ( ( ( rule__ColumnDef__Group__0 ) ) )
            // InternalMickeyLang.g:1393:2: ( ( rule__ColumnDef__Group__0 ) )
            {
            // InternalMickeyLang.g:1393:2: ( ( rule__ColumnDef__Group__0 ) )
            // InternalMickeyLang.g:1394:3: ( rule__ColumnDef__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1395:3: ( rule__ColumnDef__Group__0 )
            // InternalMickeyLang.g:1395:4: rule__ColumnDef__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ColumnDef__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleColumnDef"


    // $ANTLR start "entryRuleColumnConstraint"
    // InternalMickeyLang.g:1404:1: entryRuleColumnConstraint : ruleColumnConstraint EOF ;
    public final void entryRuleColumnConstraint() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1405:1: ( ruleColumnConstraint EOF )
            // InternalMickeyLang.g:1406:1: ruleColumnConstraint EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleColumnConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleColumnConstraint"


    // $ANTLR start "ruleColumnConstraint"
    // InternalMickeyLang.g:1413:1: ruleColumnConstraint : ( ( rule__ColumnConstraint__Alternatives ) ) ;
    public final void ruleColumnConstraint() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1417:2: ( ( ( rule__ColumnConstraint__Alternatives ) ) )
            // InternalMickeyLang.g:1418:2: ( ( rule__ColumnConstraint__Alternatives ) )
            {
            // InternalMickeyLang.g:1418:2: ( ( rule__ColumnConstraint__Alternatives ) )
            // InternalMickeyLang.g:1419:3: ( rule__ColumnConstraint__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1420:3: ( rule__ColumnConstraint__Alternatives )
            // InternalMickeyLang.g:1420:4: rule__ColumnConstraint__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleColumnConstraint"


    // $ANTLR start "entryRuleTableConstraint"
    // InternalMickeyLang.g:1429:1: entryRuleTableConstraint : ruleTableConstraint EOF ;
    public final void entryRuleTableConstraint() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1430:1: ( ruleTableConstraint EOF )
            // InternalMickeyLang.g:1431:1: ruleTableConstraint EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTableConstraintRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTableConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTableConstraintRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTableConstraint"


    // $ANTLR start "ruleTableConstraint"
    // InternalMickeyLang.g:1438:1: ruleTableConstraint : ( ( rule__TableConstraint__Alternatives ) ) ;
    public final void ruleTableConstraint() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1442:2: ( ( ( rule__TableConstraint__Alternatives ) ) )
            // InternalMickeyLang.g:1443:2: ( ( rule__TableConstraint__Alternatives ) )
            {
            // InternalMickeyLang.g:1443:2: ( ( rule__TableConstraint__Alternatives ) )
            // InternalMickeyLang.g:1444:3: ( rule__TableConstraint__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTableConstraintAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1445:3: ( rule__TableConstraint__Alternatives )
            // InternalMickeyLang.g:1445:4: rule__TableConstraint__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__TableConstraint__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTableConstraintAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTableConstraint"


    // $ANTLR start "entryRuleUniqueTableConstraint"
    // InternalMickeyLang.g:1454:1: entryRuleUniqueTableConstraint : ruleUniqueTableConstraint EOF ;
    public final void entryRuleUniqueTableConstraint() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1455:1: ( ruleUniqueTableConstraint EOF )
            // InternalMickeyLang.g:1456:1: ruleUniqueTableConstraint EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUniqueTableConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUniqueTableConstraint"


    // $ANTLR start "ruleUniqueTableConstraint"
    // InternalMickeyLang.g:1463:1: ruleUniqueTableConstraint : ( ( rule__UniqueTableConstraint__Group__0 ) ) ;
    public final void ruleUniqueTableConstraint() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1467:2: ( ( ( rule__UniqueTableConstraint__Group__0 ) ) )
            // InternalMickeyLang.g:1468:2: ( ( rule__UniqueTableConstraint__Group__0 ) )
            {
            // InternalMickeyLang.g:1468:2: ( ( rule__UniqueTableConstraint__Group__0 ) )
            // InternalMickeyLang.g:1469:3: ( rule__UniqueTableConstraint__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1470:3: ( rule__UniqueTableConstraint__Group__0 )
            // InternalMickeyLang.g:1470:4: rule__UniqueTableConstraint__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUniqueTableConstraint"


    // $ANTLR start "entryRulePrimaryConstraint"
    // InternalMickeyLang.g:1479:1: entryRulePrimaryConstraint : rulePrimaryConstraint EOF ;
    public final void entryRulePrimaryConstraint() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1480:1: ( rulePrimaryConstraint EOF )
            // InternalMickeyLang.g:1481:1: rulePrimaryConstraint EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrimaryConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrimaryConstraint"


    // $ANTLR start "rulePrimaryConstraint"
    // InternalMickeyLang.g:1488:1: rulePrimaryConstraint : ( ( rule__PrimaryConstraint__Group__0 ) ) ;
    public final void rulePrimaryConstraint() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1492:2: ( ( ( rule__PrimaryConstraint__Group__0 ) ) )
            // InternalMickeyLang.g:1493:2: ( ( rule__PrimaryConstraint__Group__0 ) )
            {
            // InternalMickeyLang.g:1493:2: ( ( rule__PrimaryConstraint__Group__0 ) )
            // InternalMickeyLang.g:1494:3: ( rule__PrimaryConstraint__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1495:3: ( rule__PrimaryConstraint__Group__0 )
            // InternalMickeyLang.g:1495:4: rule__PrimaryConstraint__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrimaryConstraint"


    // $ANTLR start "entryRuleCheckTableConstraint"
    // InternalMickeyLang.g:1504:1: entryRuleCheckTableConstraint : ruleCheckTableConstraint EOF ;
    public final void entryRuleCheckTableConstraint() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1505:1: ( ruleCheckTableConstraint EOF )
            // InternalMickeyLang.g:1506:1: ruleCheckTableConstraint EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCheckTableConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCheckTableConstraint"


    // $ANTLR start "ruleCheckTableConstraint"
    // InternalMickeyLang.g:1513:1: ruleCheckTableConstraint : ( ( rule__CheckTableConstraint__Group__0 ) ) ;
    public final void ruleCheckTableConstraint() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1517:2: ( ( ( rule__CheckTableConstraint__Group__0 ) ) )
            // InternalMickeyLang.g:1518:2: ( ( rule__CheckTableConstraint__Group__0 ) )
            {
            // InternalMickeyLang.g:1518:2: ( ( rule__CheckTableConstraint__Group__0 ) )
            // InternalMickeyLang.g:1519:3: ( rule__CheckTableConstraint__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1520:3: ( rule__CheckTableConstraint__Group__0 )
            // InternalMickeyLang.g:1520:4: rule__CheckTableConstraint__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCheckTableConstraint"


    // $ANTLR start "entryRuleIndexedColumn"
    // InternalMickeyLang.g:1529:1: entryRuleIndexedColumn : ruleIndexedColumn EOF ;
    public final void entryRuleIndexedColumn() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1530:1: ( ruleIndexedColumn EOF )
            // InternalMickeyLang.g:1531:1: ruleIndexedColumn EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleIndexedColumn"


    // $ANTLR start "ruleIndexedColumn"
    // InternalMickeyLang.g:1538:1: ruleIndexedColumn : ( ( rule__IndexedColumn__Group__0 ) ) ;
    public final void ruleIndexedColumn() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1542:2: ( ( ( rule__IndexedColumn__Group__0 ) ) )
            // InternalMickeyLang.g:1543:2: ( ( rule__IndexedColumn__Group__0 ) )
            {
            // InternalMickeyLang.g:1543:2: ( ( rule__IndexedColumn__Group__0 ) )
            // InternalMickeyLang.g:1544:3: ( rule__IndexedColumn__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1545:3: ( rule__IndexedColumn__Group__0 )
            // InternalMickeyLang.g:1545:4: rule__IndexedColumn__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleIndexedColumn"


    // $ANTLR start "entryRuleDefaultValue"
    // InternalMickeyLang.g:1554:1: entryRuleDefaultValue : ruleDefaultValue EOF ;
    public final void entryRuleDefaultValue() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1555:1: ( ruleDefaultValue EOF )
            // InternalMickeyLang.g:1556:1: ruleDefaultValue EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDefaultValue();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDefaultValue"


    // $ANTLR start "ruleDefaultValue"
    // InternalMickeyLang.g:1563:1: ruleDefaultValue : ( ( rule__DefaultValue__Alternatives ) ) ;
    public final void ruleDefaultValue() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1567:2: ( ( ( rule__DefaultValue__Alternatives ) ) )
            // InternalMickeyLang.g:1568:2: ( ( rule__DefaultValue__Alternatives ) )
            {
            // InternalMickeyLang.g:1568:2: ( ( rule__DefaultValue__Alternatives ) )
            // InternalMickeyLang.g:1569:3: ( rule__DefaultValue__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1570:3: ( rule__DefaultValue__Alternatives )
            // InternalMickeyLang.g:1570:4: rule__DefaultValue__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDefaultValue"


    // $ANTLR start "entryRuleConflictClause"
    // InternalMickeyLang.g:1579:1: entryRuleConflictClause : ruleConflictClause EOF ;
    public final void entryRuleConflictClause() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1580:1: ( ruleConflictClause EOF )
            // InternalMickeyLang.g:1581:1: ruleConflictClause EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictClauseRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleConflictClause();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictClauseRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleConflictClause"


    // $ANTLR start "ruleConflictClause"
    // InternalMickeyLang.g:1588:1: ruleConflictClause : ( ( rule__ConflictClause__Group__0 ) ) ;
    public final void ruleConflictClause() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1592:2: ( ( ( rule__ConflictClause__Group__0 ) ) )
            // InternalMickeyLang.g:1593:2: ( ( rule__ConflictClause__Group__0 ) )
            {
            // InternalMickeyLang.g:1593:2: ( ( rule__ConflictClause__Group__0 ) )
            // InternalMickeyLang.g:1594:3: ( rule__ConflictClause__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictClauseAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1595:3: ( rule__ConflictClause__Group__0 )
            // InternalMickeyLang.g:1595:4: rule__ConflictClause__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ConflictClause__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictClauseAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleConflictClause"


    // $ANTLR start "entryRuleDMLStatement"
    // InternalMickeyLang.g:1604:1: entryRuleDMLStatement : ruleDMLStatement EOF ;
    public final void entryRuleDMLStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1605:1: ( ruleDMLStatement EOF )
            // InternalMickeyLang.g:1606:1: ruleDMLStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDMLStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDMLStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDMLStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDMLStatement"


    // $ANTLR start "ruleDMLStatement"
    // InternalMickeyLang.g:1613:1: ruleDMLStatement : ( ( rule__DMLStatement__Alternatives ) ) ;
    public final void ruleDMLStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1617:2: ( ( ( rule__DMLStatement__Alternatives ) ) )
            // InternalMickeyLang.g:1618:2: ( ( rule__DMLStatement__Alternatives ) )
            {
            // InternalMickeyLang.g:1618:2: ( ( rule__DMLStatement__Alternatives ) )
            // InternalMickeyLang.g:1619:3: ( rule__DMLStatement__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDMLStatementAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1620:3: ( rule__DMLStatement__Alternatives )
            // InternalMickeyLang.g:1620:4: rule__DMLStatement__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__DMLStatement__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDMLStatementAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDMLStatement"


    // $ANTLR start "entryRuleDeleteStatement"
    // InternalMickeyLang.g:1629:1: entryRuleDeleteStatement : ruleDeleteStatement EOF ;
    public final void entryRuleDeleteStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1630:1: ( ruleDeleteStatement EOF )
            // InternalMickeyLang.g:1631:1: ruleDeleteStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleDeleteStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleDeleteStatement"


    // $ANTLR start "ruleDeleteStatement"
    // InternalMickeyLang.g:1638:1: ruleDeleteStatement : ( ( rule__DeleteStatement__Group__0 ) ) ;
    public final void ruleDeleteStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1642:2: ( ( ( rule__DeleteStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1643:2: ( ( rule__DeleteStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1643:2: ( ( rule__DeleteStatement__Group__0 ) )
            // InternalMickeyLang.g:1644:3: ( rule__DeleteStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1645:3: ( rule__DeleteStatement__Group__0 )
            // InternalMickeyLang.g:1645:4: rule__DeleteStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleDeleteStatement"


    // $ANTLR start "entryRuleInsertStatement"
    // InternalMickeyLang.g:1654:1: entryRuleInsertStatement : ruleInsertStatement EOF ;
    public final void entryRuleInsertStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1655:1: ( ruleInsertStatement EOF )
            // InternalMickeyLang.g:1656:1: ruleInsertStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleInsertStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleInsertStatement"


    // $ANTLR start "ruleInsertStatement"
    // InternalMickeyLang.g:1663:1: ruleInsertStatement : ( ( rule__InsertStatement__Group__0 ) ) ;
    public final void ruleInsertStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1667:2: ( ( ( rule__InsertStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1668:2: ( ( rule__InsertStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1668:2: ( ( rule__InsertStatement__Group__0 ) )
            // InternalMickeyLang.g:1669:3: ( rule__InsertStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1670:3: ( rule__InsertStatement__Group__0 )
            // InternalMickeyLang.g:1670:4: rule__InsertStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleInsertStatement"


    // $ANTLR start "entryRuleUpdateStatement"
    // InternalMickeyLang.g:1679:1: entryRuleUpdateStatement : ruleUpdateStatement EOF ;
    public final void entryRuleUpdateStatement() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1680:1: ( ruleUpdateStatement EOF )
            // InternalMickeyLang.g:1681:1: ruleUpdateStatement EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUpdateStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUpdateStatement"


    // $ANTLR start "ruleUpdateStatement"
    // InternalMickeyLang.g:1688:1: ruleUpdateStatement : ( ( rule__UpdateStatement__Group__0 ) ) ;
    public final void ruleUpdateStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1692:2: ( ( ( rule__UpdateStatement__Group__0 ) ) )
            // InternalMickeyLang.g:1693:2: ( ( rule__UpdateStatement__Group__0 ) )
            {
            // InternalMickeyLang.g:1693:2: ( ( rule__UpdateStatement__Group__0 ) )
            // InternalMickeyLang.g:1694:3: ( rule__UpdateStatement__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1695:3: ( rule__UpdateStatement__Group__0 )
            // InternalMickeyLang.g:1695:4: rule__UpdateStatement__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUpdateStatement"


    // $ANTLR start "entryRuleUpdateColumnExpression"
    // InternalMickeyLang.g:1704:1: entryRuleUpdateColumnExpression : ruleUpdateColumnExpression EOF ;
    public final void entryRuleUpdateColumnExpression() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1705:1: ( ruleUpdateColumnExpression EOF )
            // InternalMickeyLang.g:1706:1: ruleUpdateColumnExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUpdateColumnExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUpdateColumnExpression"


    // $ANTLR start "ruleUpdateColumnExpression"
    // InternalMickeyLang.g:1713:1: ruleUpdateColumnExpression : ( ( rule__UpdateColumnExpression__Group__0 ) ) ;
    public final void ruleUpdateColumnExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1717:2: ( ( ( rule__UpdateColumnExpression__Group__0 ) ) )
            // InternalMickeyLang.g:1718:2: ( ( rule__UpdateColumnExpression__Group__0 ) )
            {
            // InternalMickeyLang.g:1718:2: ( ( rule__UpdateColumnExpression__Group__0 ) )
            // InternalMickeyLang.g:1719:3: ( rule__UpdateColumnExpression__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1720:3: ( rule__UpdateColumnExpression__Group__0 )
            // InternalMickeyLang.g:1720:4: rule__UpdateColumnExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__UpdateColumnExpression__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUpdateColumnExpression"


    // $ANTLR start "entryRuleSignedNumber"
    // InternalMickeyLang.g:1729:1: entryRuleSignedNumber : ruleSignedNumber EOF ;
    public final void entryRuleSignedNumber() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1730:1: ( ruleSignedNumber EOF )
            // InternalMickeyLang.g:1731:1: ruleSignedNumber EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSignedNumberRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSignedNumber();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSignedNumberRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSignedNumber"


    // $ANTLR start "ruleSignedNumber"
    // InternalMickeyLang.g:1738:1: ruleSignedNumber : ( ( rule__SignedNumber__Group__0 ) ) ;
    public final void ruleSignedNumber() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1742:2: ( ( ( rule__SignedNumber__Group__0 ) ) )
            // InternalMickeyLang.g:1743:2: ( ( rule__SignedNumber__Group__0 ) )
            {
            // InternalMickeyLang.g:1743:2: ( ( rule__SignedNumber__Group__0 ) )
            // InternalMickeyLang.g:1744:3: ( rule__SignedNumber__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSignedNumberAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1745:3: ( rule__SignedNumber__Group__0 )
            // InternalMickeyLang.g:1745:4: rule__SignedNumber__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SignedNumber__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSignedNumberAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSignedNumber"


    // $ANTLR start "entryRuleQualifiedName"
    // InternalMickeyLang.g:1754:1: entryRuleQualifiedName : ruleQualifiedName EOF ;
    public final void entryRuleQualifiedName() throws RecognitionException {
        try {
            // InternalMickeyLang.g:1755:1: ( ruleQualifiedName EOF )
            // InternalMickeyLang.g:1756:1: ruleQualifiedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleQualifiedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getQualifiedNameRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleQualifiedName"


    // $ANTLR start "ruleQualifiedName"
    // InternalMickeyLang.g:1763:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ;
    public final void ruleQualifiedName() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1767:2: ( ( ( rule__QualifiedName__Group__0 ) ) )
            // InternalMickeyLang.g:1768:2: ( ( rule__QualifiedName__Group__0 ) )
            {
            // InternalMickeyLang.g:1768:2: ( ( rule__QualifiedName__Group__0 ) )
            // InternalMickeyLang.g:1769:3: ( rule__QualifiedName__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameAccess().getGroup()); 
            }
            // InternalMickeyLang.g:1770:3: ( rule__QualifiedName__Group__0 )
            // InternalMickeyLang.g:1770:4: rule__QualifiedName__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getQualifiedNameAccess().getGroup()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleQualifiedName"


    // $ANTLR start "ruleCompoundOperator"
    // InternalMickeyLang.g:1779:1: ruleCompoundOperator : ( ( rule__CompoundOperator__Alternatives ) ) ;
    public final void ruleCompoundOperator() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1783:1: ( ( ( rule__CompoundOperator__Alternatives ) ) )
            // InternalMickeyLang.g:1784:2: ( ( rule__CompoundOperator__Alternatives ) )
            {
            // InternalMickeyLang.g:1784:2: ( ( rule__CompoundOperator__Alternatives ) )
            // InternalMickeyLang.g:1785:3: ( rule__CompoundOperator__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundOperatorAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1786:3: ( rule__CompoundOperator__Alternatives )
            // InternalMickeyLang.g:1786:4: rule__CompoundOperator__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__CompoundOperator__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCompoundOperatorAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCompoundOperator"


    // $ANTLR start "ruleSqliteDataType"
    // InternalMickeyLang.g:1795:1: ruleSqliteDataType : ( ( rule__SqliteDataType__Alternatives ) ) ;
    public final void ruleSqliteDataType() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1799:1: ( ( ( rule__SqliteDataType__Alternatives ) ) )
            // InternalMickeyLang.g:1800:2: ( ( rule__SqliteDataType__Alternatives ) )
            {
            // InternalMickeyLang.g:1800:2: ( ( rule__SqliteDataType__Alternatives ) )
            // InternalMickeyLang.g:1801:3: ( rule__SqliteDataType__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSqliteDataTypeAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1802:3: ( rule__SqliteDataType__Alternatives )
            // InternalMickeyLang.g:1802:4: rule__SqliteDataType__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__SqliteDataType__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSqliteDataTypeAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSqliteDataType"


    // $ANTLR start "ruleColumnType"
    // InternalMickeyLang.g:1811:1: ruleColumnType : ( ( rule__ColumnType__Alternatives ) ) ;
    public final void ruleColumnType() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1815:1: ( ( ( rule__ColumnType__Alternatives ) ) )
            // InternalMickeyLang.g:1816:2: ( ( rule__ColumnType__Alternatives ) )
            {
            // InternalMickeyLang.g:1816:2: ( ( rule__ColumnType__Alternatives ) )
            // InternalMickeyLang.g:1817:3: ( rule__ColumnType__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnTypeAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1818:3: ( rule__ColumnType__Alternatives )
            // InternalMickeyLang.g:1818:4: rule__ColumnType__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ColumnType__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnTypeAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleColumnType"


    // $ANTLR start "ruleConflictResolution"
    // InternalMickeyLang.g:1827:1: ruleConflictResolution : ( ( rule__ConflictResolution__Alternatives ) ) ;
    public final void ruleConflictResolution() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1831:1: ( ( ( rule__ConflictResolution__Alternatives ) ) )
            // InternalMickeyLang.g:1832:2: ( ( rule__ConflictResolution__Alternatives ) )
            {
            // InternalMickeyLang.g:1832:2: ( ( rule__ConflictResolution__Alternatives ) )
            // InternalMickeyLang.g:1833:3: ( rule__ConflictResolution__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictResolutionAccess().getAlternatives()); 
            }
            // InternalMickeyLang.g:1834:3: ( rule__ConflictResolution__Alternatives )
            // InternalMickeyLang.g:1834:4: rule__ConflictResolution__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ConflictResolution__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictResolutionAccess().getAlternatives()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleConflictResolution"


    // $ANTLR start "rule__MickeyBlock__Alternatives"
    // InternalMickeyLang.g:1842:1: rule__MickeyBlock__Alternatives : ( ( ruleMickeyFunction ) | ( ruleActionStatement ) | ( ruleDDLStatement ) | ( ruleMigrationBlock ) );
    public final void rule__MickeyBlock__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1846:1: ( ( ruleMickeyFunction ) | ( ruleActionStatement ) | ( ruleDDLStatement ) | ( ruleMigrationBlock ) )
            int alt1=4;
            switch ( input.LA(1) ) {
            case 61:
                {
                alt1=1;
                }
                break;
            case 68:
                {
                alt1=2;
                }
                break;
            case 93:
            case 99:
            case 102:
                {
                alt1=3;
                }
                break;
            case 72:
                {
                alt1=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }

            switch (alt1) {
                case 1 :
                    // InternalMickeyLang.g:1847:2: ( ruleMickeyFunction )
                    {
                    // InternalMickeyLang.g:1847:2: ( ruleMickeyFunction )
                    // InternalMickeyLang.g:1848:3: ruleMickeyFunction
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMickeyBlockAccess().getMickeyFunctionParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleMickeyFunction();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMickeyBlockAccess().getMickeyFunctionParserRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:1853:2: ( ruleActionStatement )
                    {
                    // InternalMickeyLang.g:1853:2: ( ruleActionStatement )
                    // InternalMickeyLang.g:1854:3: ruleActionStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMickeyBlockAccess().getActionStatementParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleActionStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMickeyBlockAccess().getActionStatementParserRuleCall_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:1859:2: ( ruleDDLStatement )
                    {
                    // InternalMickeyLang.g:1859:2: ( ruleDDLStatement )
                    // InternalMickeyLang.g:1860:3: ruleDDLStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMickeyBlockAccess().getDDLStatementParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleDDLStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMickeyBlockAccess().getDDLStatementParserRuleCall_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:1865:2: ( ruleMigrationBlock )
                    {
                    // InternalMickeyLang.g:1865:2: ( ruleMigrationBlock )
                    // InternalMickeyLang.g:1866:3: ruleMigrationBlock
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMickeyBlockAccess().getMigrationBlockParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleMigrationBlock();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMickeyBlockAccess().getMigrationBlockParserRuleCall_3()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyBlock__Alternatives"


    // $ANTLR start "rule__NotifyContentUriSegment__Alternatives"
    // InternalMickeyLang.g:1875:1: rule__NotifyContentUriSegment__Alternatives : ( ( ( rule__NotifyContentUriSegment__NameAssignment_0 ) ) | ( ( rule__NotifyContentUriSegment__Group_1__0 ) ) );
    public final void rule__NotifyContentUriSegment__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1879:1: ( ( ( rule__NotifyContentUriSegment__NameAssignment_0 ) ) | ( ( rule__NotifyContentUriSegment__Group_1__0 ) ) )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==RULE_ID) ) {
                alt2=1;
            }
            else if ( (LA2_0==64) ) {
                alt2=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // InternalMickeyLang.g:1880:2: ( ( rule__NotifyContentUriSegment__NameAssignment_0 ) )
                    {
                    // InternalMickeyLang.g:1880:2: ( ( rule__NotifyContentUriSegment__NameAssignment_0 ) )
                    // InternalMickeyLang.g:1881:3: ( rule__NotifyContentUriSegment__NameAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNotifyContentUriSegmentAccess().getNameAssignment_0()); 
                    }
                    // InternalMickeyLang.g:1882:3: ( rule__NotifyContentUriSegment__NameAssignment_0 )
                    // InternalMickeyLang.g:1882:4: rule__NotifyContentUriSegment__NameAssignment_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__NotifyContentUriSegment__NameAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNotifyContentUriSegmentAccess().getNameAssignment_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:1886:2: ( ( rule__NotifyContentUriSegment__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:1886:2: ( ( rule__NotifyContentUriSegment__Group_1__0 ) )
                    // InternalMickeyLang.g:1887:3: ( rule__NotifyContentUriSegment__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNotifyContentUriSegmentAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:1888:3: ( rule__NotifyContentUriSegment__Group_1__0 )
                    // InternalMickeyLang.g:1888:4: rule__NotifyContentUriSegment__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__NotifyContentUriSegment__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNotifyContentUriSegmentAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Alternatives"


    // $ANTLR start "rule__ContentUriSegment__Alternatives"
    // InternalMickeyLang.g:1896:1: rule__ContentUriSegment__Alternatives : ( ( ( rule__ContentUriSegment__NameAssignment_0 ) ) | ( ( rule__ContentUriSegment__Group_1__0 ) ) );
    public final void rule__ContentUriSegment__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1900:1: ( ( ( rule__ContentUriSegment__NameAssignment_0 ) ) | ( ( rule__ContentUriSegment__Group_1__0 ) ) )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==RULE_ID) ) {
                alt3=1;
            }
            else if ( (LA3_0==64) ) {
                alt3=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // InternalMickeyLang.g:1901:2: ( ( rule__ContentUriSegment__NameAssignment_0 ) )
                    {
                    // InternalMickeyLang.g:1901:2: ( ( rule__ContentUriSegment__NameAssignment_0 ) )
                    // InternalMickeyLang.g:1902:3: ( rule__ContentUriSegment__NameAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getContentUriSegmentAccess().getNameAssignment_0()); 
                    }
                    // InternalMickeyLang.g:1903:3: ( rule__ContentUriSegment__NameAssignment_0 )
                    // InternalMickeyLang.g:1903:4: rule__ContentUriSegment__NameAssignment_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ContentUriSegment__NameAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getContentUriSegmentAccess().getNameAssignment_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:1907:2: ( ( rule__ContentUriSegment__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:1907:2: ( ( rule__ContentUriSegment__Group_1__0 ) )
                    // InternalMickeyLang.g:1908:3: ( rule__ContentUriSegment__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getContentUriSegmentAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:1909:3: ( rule__ContentUriSegment__Group_1__0 )
                    // InternalMickeyLang.g:1909:4: rule__ContentUriSegment__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ContentUriSegment__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getContentUriSegmentAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Alternatives"


    // $ANTLR start "rule__ExprMult__OpAlternatives_1_1_0"
    // InternalMickeyLang.g:1917:1: rule__ExprMult__OpAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) | ( '%' ) );
    public final void rule__ExprMult__OpAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1921:1: ( ( '*' ) | ( '/' ) | ( '%' ) )
            int alt4=3;
            switch ( input.LA(1) ) {
            case 12:
                {
                alt4=1;
                }
                break;
            case 13:
                {
                alt4=2;
                }
                break;
            case 14:
                {
                alt4=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }

            switch (alt4) {
                case 1 :
                    // InternalMickeyLang.g:1922:2: ( '*' )
                    {
                    // InternalMickeyLang.g:1922:2: ( '*' )
                    // InternalMickeyLang.g:1923:3: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprMultAccess().getOpAsteriskKeyword_1_1_0_0()); 
                    }
                    match(input,12,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprMultAccess().getOpAsteriskKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:1928:2: ( '/' )
                    {
                    // InternalMickeyLang.g:1928:2: ( '/' )
                    // InternalMickeyLang.g:1929:3: '/'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprMultAccess().getOpSolidusKeyword_1_1_0_1()); 
                    }
                    match(input,13,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprMultAccess().getOpSolidusKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:1934:2: ( '%' )
                    {
                    // InternalMickeyLang.g:1934:2: ( '%' )
                    // InternalMickeyLang.g:1935:3: '%'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprMultAccess().getOpPercentSignKeyword_1_1_0_2()); 
                    }
                    match(input,14,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprMultAccess().getOpPercentSignKeyword_1_1_0_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__OpAlternatives_1_1_0"


    // $ANTLR start "rule__ExprAdd__OpAlternatives_1_1_0"
    // InternalMickeyLang.g:1944:1: rule__ExprAdd__OpAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) );
    public final void rule__ExprAdd__OpAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1948:1: ( ( '+' ) | ( '-' ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==15) ) {
                alt5=1;
            }
            else if ( (LA5_0==16) ) {
                alt5=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // InternalMickeyLang.g:1949:2: ( '+' )
                    {
                    // InternalMickeyLang.g:1949:2: ( '+' )
                    // InternalMickeyLang.g:1950:3: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprAddAccess().getOpPlusSignKeyword_1_1_0_0()); 
                    }
                    match(input,15,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprAddAccess().getOpPlusSignKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:1955:2: ( '-' )
                    {
                    // InternalMickeyLang.g:1955:2: ( '-' )
                    // InternalMickeyLang.g:1956:3: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprAddAccess().getOpHyphenMinusKeyword_1_1_0_1()); 
                    }
                    match(input,16,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprAddAccess().getOpHyphenMinusKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__OpAlternatives_1_1_0"


    // $ANTLR start "rule__ExprBit__OpAlternatives_1_1_0"
    // InternalMickeyLang.g:1965:1: rule__ExprBit__OpAlternatives_1_1_0 : ( ( '<<' ) | ( '>>' ) | ( '&' ) | ( '|' ) );
    public final void rule__ExprBit__OpAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:1969:1: ( ( '<<' ) | ( '>>' ) | ( '&' ) | ( '|' ) )
            int alt6=4;
            switch ( input.LA(1) ) {
            case 17:
                {
                alt6=1;
                }
                break;
            case 18:
                {
                alt6=2;
                }
                break;
            case 19:
                {
                alt6=3;
                }
                break;
            case 20:
                {
                alt6=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }

            switch (alt6) {
                case 1 :
                    // InternalMickeyLang.g:1970:2: ( '<<' )
                    {
                    // InternalMickeyLang.g:1970:2: ( '<<' )
                    // InternalMickeyLang.g:1971:3: '<<'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprBitAccess().getOpLessThanSignLessThanSignKeyword_1_1_0_0()); 
                    }
                    match(input,17,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprBitAccess().getOpLessThanSignLessThanSignKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:1976:2: ( '>>' )
                    {
                    // InternalMickeyLang.g:1976:2: ( '>>' )
                    // InternalMickeyLang.g:1977:3: '>>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprBitAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_1_0_1()); 
                    }
                    match(input,18,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprBitAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:1982:2: ( '&' )
                    {
                    // InternalMickeyLang.g:1982:2: ( '&' )
                    // InternalMickeyLang.g:1983:3: '&'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprBitAccess().getOpAmpersandKeyword_1_1_0_2()); 
                    }
                    match(input,19,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprBitAccess().getOpAmpersandKeyword_1_1_0_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:1988:2: ( '|' )
                    {
                    // InternalMickeyLang.g:1988:2: ( '|' )
                    // InternalMickeyLang.g:1989:3: '|'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprBitAccess().getOpVerticalLineKeyword_1_1_0_3()); 
                    }
                    match(input,20,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprBitAccess().getOpVerticalLineKeyword_1_1_0_3()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__OpAlternatives_1_1_0"


    // $ANTLR start "rule__ExprRelate__OpAlternatives_1_1_0"
    // InternalMickeyLang.g:1998:1: rule__ExprRelate__OpAlternatives_1_1_0 : ( ( '<' ) | ( '<=' ) | ( '>' ) | ( '>=' ) );
    public final void rule__ExprRelate__OpAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2002:1: ( ( '<' ) | ( '<=' ) | ( '>' ) | ( '>=' ) )
            int alt7=4;
            switch ( input.LA(1) ) {
            case 21:
                {
                alt7=1;
                }
                break;
            case 22:
                {
                alt7=2;
                }
                break;
            case 23:
                {
                alt7=3;
                }
                break;
            case 24:
                {
                alt7=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }

            switch (alt7) {
                case 1 :
                    // InternalMickeyLang.g:2003:2: ( '<' )
                    {
                    // InternalMickeyLang.g:2003:2: ( '<' )
                    // InternalMickeyLang.g:2004:3: '<'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprRelateAccess().getOpLessThanSignKeyword_1_1_0_0()); 
                    }
                    match(input,21,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprRelateAccess().getOpLessThanSignKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2009:2: ( '<=' )
                    {
                    // InternalMickeyLang.g:2009:2: ( '<=' )
                    // InternalMickeyLang.g:2010:3: '<='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprRelateAccess().getOpLessThanSignEqualsSignKeyword_1_1_0_1()); 
                    }
                    match(input,22,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprRelateAccess().getOpLessThanSignEqualsSignKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2015:2: ( '>' )
                    {
                    // InternalMickeyLang.g:2015:2: ( '>' )
                    // InternalMickeyLang.g:2016:3: '>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprRelateAccess().getOpGreaterThanSignKeyword_1_1_0_2()); 
                    }
                    match(input,23,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprRelateAccess().getOpGreaterThanSignKeyword_1_1_0_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2021:2: ( '>=' )
                    {
                    // InternalMickeyLang.g:2021:2: ( '>=' )
                    // InternalMickeyLang.g:2022:3: '>='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprRelateAccess().getOpGreaterThanSignEqualsSignKeyword_1_1_0_3()); 
                    }
                    match(input,24,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprRelateAccess().getOpGreaterThanSignEqualsSignKeyword_1_1_0_3()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__OpAlternatives_1_1_0"


    // $ANTLR start "rule__ExprEqual__OpAlternatives_1_1_0"
    // InternalMickeyLang.g:2031:1: rule__ExprEqual__OpAlternatives_1_1_0 : ( ( '=' ) | ( '==' ) | ( '!=' ) | ( '<>' ) | ( 'is' ) | ( 'is not' ) | ( 'in' ) | ( 'not in' ) | ( 'like' ) | ( 'glob' ) | ( 'match' ) | ( 'regexp' ) );
    public final void rule__ExprEqual__OpAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2035:1: ( ( '=' ) | ( '==' ) | ( '!=' ) | ( '<>' ) | ( 'is' ) | ( 'is not' ) | ( 'in' ) | ( 'not in' ) | ( 'like' ) | ( 'glob' ) | ( 'match' ) | ( 'regexp' ) )
            int alt8=12;
            switch ( input.LA(1) ) {
            case 25:
                {
                alt8=1;
                }
                break;
            case 26:
                {
                alt8=2;
                }
                break;
            case 27:
                {
                alt8=3;
                }
                break;
            case 28:
                {
                alt8=4;
                }
                break;
            case 29:
                {
                alt8=5;
                }
                break;
            case 30:
                {
                alt8=6;
                }
                break;
            case 31:
                {
                alt8=7;
                }
                break;
            case 32:
                {
                alt8=8;
                }
                break;
            case 33:
                {
                alt8=9;
                }
                break;
            case 34:
                {
                alt8=10;
                }
                break;
            case 35:
                {
                alt8=11;
                }
                break;
            case 36:
                {
                alt8=12;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }

            switch (alt8) {
                case 1 :
                    // InternalMickeyLang.g:2036:2: ( '=' )
                    {
                    // InternalMickeyLang.g:2036:2: ( '=' )
                    // InternalMickeyLang.g:2037:3: '='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpEqualsSignKeyword_1_1_0_0()); 
                    }
                    match(input,25,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpEqualsSignKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2042:2: ( '==' )
                    {
                    // InternalMickeyLang.g:2042:2: ( '==' )
                    // InternalMickeyLang.g:2043:3: '=='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpEqualsSignEqualsSignKeyword_1_1_0_1()); 
                    }
                    match(input,26,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpEqualsSignEqualsSignKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2048:2: ( '!=' )
                    {
                    // InternalMickeyLang.g:2048:2: ( '!=' )
                    // InternalMickeyLang.g:2049:3: '!='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpExclamationMarkEqualsSignKeyword_1_1_0_2()); 
                    }
                    match(input,27,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpExclamationMarkEqualsSignKeyword_1_1_0_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2054:2: ( '<>' )
                    {
                    // InternalMickeyLang.g:2054:2: ( '<>' )
                    // InternalMickeyLang.g:2055:3: '<>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpLessThanSignGreaterThanSignKeyword_1_1_0_3()); 
                    }
                    match(input,28,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpLessThanSignGreaterThanSignKeyword_1_1_0_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2060:2: ( 'is' )
                    {
                    // InternalMickeyLang.g:2060:2: ( 'is' )
                    // InternalMickeyLang.g:2061:3: 'is'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpIsKeyword_1_1_0_4()); 
                    }
                    match(input,29,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpIsKeyword_1_1_0_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalMickeyLang.g:2066:2: ( 'is not' )
                    {
                    // InternalMickeyLang.g:2066:2: ( 'is not' )
                    // InternalMickeyLang.g:2067:3: 'is not'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpIsNotKeyword_1_1_0_5()); 
                    }
                    match(input,30,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpIsNotKeyword_1_1_0_5()); 
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalMickeyLang.g:2072:2: ( 'in' )
                    {
                    // InternalMickeyLang.g:2072:2: ( 'in' )
                    // InternalMickeyLang.g:2073:3: 'in'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpInKeyword_1_1_0_6()); 
                    }
                    match(input,31,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpInKeyword_1_1_0_6()); 
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalMickeyLang.g:2078:2: ( 'not in' )
                    {
                    // InternalMickeyLang.g:2078:2: ( 'not in' )
                    // InternalMickeyLang.g:2079:3: 'not in'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpNotInKeyword_1_1_0_7()); 
                    }
                    match(input,32,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpNotInKeyword_1_1_0_7()); 
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalMickeyLang.g:2084:2: ( 'like' )
                    {
                    // InternalMickeyLang.g:2084:2: ( 'like' )
                    // InternalMickeyLang.g:2085:3: 'like'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpLikeKeyword_1_1_0_8()); 
                    }
                    match(input,33,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpLikeKeyword_1_1_0_8()); 
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalMickeyLang.g:2090:2: ( 'glob' )
                    {
                    // InternalMickeyLang.g:2090:2: ( 'glob' )
                    // InternalMickeyLang.g:2091:3: 'glob'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpGlobKeyword_1_1_0_9()); 
                    }
                    match(input,34,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpGlobKeyword_1_1_0_9()); 
                    }

                    }


                    }
                    break;
                case 11 :
                    // InternalMickeyLang.g:2096:2: ( 'match' )
                    {
                    // InternalMickeyLang.g:2096:2: ( 'match' )
                    // InternalMickeyLang.g:2097:3: 'match'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpMatchKeyword_1_1_0_10()); 
                    }
                    match(input,35,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpMatchKeyword_1_1_0_10()); 
                    }

                    }


                    }
                    break;
                case 12 :
                    // InternalMickeyLang.g:2102:2: ( 'regexp' )
                    {
                    // InternalMickeyLang.g:2102:2: ( 'regexp' )
                    // InternalMickeyLang.g:2103:3: 'regexp'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExprEqualAccess().getOpRegexpKeyword_1_1_0_11()); 
                    }
                    match(input,36,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExprEqualAccess().getOpRegexpKeyword_1_1_0_11()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__OpAlternatives_1_1_0"


    // $ANTLR start "rule__NullExpression__Alternatives"
    // InternalMickeyLang.g:2112:1: rule__NullExpression__Alternatives : ( ( ( rule__NullExpression__Group_0__0 ) ) | ( ( rule__NullExpression__Group_1__0 ) ) );
    public final void rule__NullExpression__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2116:1: ( ( ( rule__NullExpression__Group_0__0 ) ) | ( ( rule__NullExpression__Group_1__0 ) ) )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==74) ) {
                alt9=1;
            }
            else if ( ((LA9_0>=37 && LA9_0<=38)) ) {
                alt9=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }
            switch (alt9) {
                case 1 :
                    // InternalMickeyLang.g:2117:2: ( ( rule__NullExpression__Group_0__0 ) )
                    {
                    // InternalMickeyLang.g:2117:2: ( ( rule__NullExpression__Group_0__0 ) )
                    // InternalMickeyLang.g:2118:3: ( rule__NullExpression__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNullExpressionAccess().getGroup_0()); 
                    }
                    // InternalMickeyLang.g:2119:3: ( rule__NullExpression__Group_0__0 )
                    // InternalMickeyLang.g:2119:4: rule__NullExpression__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__NullExpression__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNullExpressionAccess().getGroup_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2123:2: ( ( rule__NullExpression__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:2123:2: ( ( rule__NullExpression__Group_1__0 ) )
                    // InternalMickeyLang.g:2124:3: ( rule__NullExpression__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNullExpressionAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:2125:3: ( rule__NullExpression__Group_1__0 )
                    // InternalMickeyLang.g:2125:4: rule__NullExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__NullExpression__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNullExpressionAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Alternatives"


    // $ANTLR start "rule__NullExpression__Alternatives_1_1"
    // InternalMickeyLang.g:2133:1: rule__NullExpression__Alternatives_1_1 : ( ( 'not null' ) | ( 'notnull' ) );
    public final void rule__NullExpression__Alternatives_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2137:1: ( ( 'not null' ) | ( 'notnull' ) )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==37) ) {
                alt10=1;
            }
            else if ( (LA10_0==38) ) {
                alt10=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }
            switch (alt10) {
                case 1 :
                    // InternalMickeyLang.g:2138:2: ( 'not null' )
                    {
                    // InternalMickeyLang.g:2138:2: ( 'not null' )
                    // InternalMickeyLang.g:2139:3: 'not null'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNullExpressionAccess().getNotNullKeyword_1_1_0()); 
                    }
                    match(input,37,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNullExpressionAccess().getNotNullKeyword_1_1_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2144:2: ( 'notnull' )
                    {
                    // InternalMickeyLang.g:2144:2: ( 'notnull' )
                    // InternalMickeyLang.g:2145:3: 'notnull'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNullExpressionAccess().getNotnullKeyword_1_1_1()); 
                    }
                    match(input,38,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNullExpressionAccess().getNotnullKeyword_1_1_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Alternatives_1_1"


    // $ANTLR start "rule__PrimaryExpression__Alternatives"
    // InternalMickeyLang.g:2154:1: rule__PrimaryExpression__Alternatives : ( ( ( rule__PrimaryExpression__Group_0__0 ) ) | ( ( rule__PrimaryExpression__Group_1__0 ) ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) | ( ( rule__PrimaryExpression__Group_3__0 ) ) | ( ( rule__PrimaryExpression__Group_4__0 ) ) | ( ( rule__PrimaryExpression__Group_5__0 ) ) | ( ( rule__PrimaryExpression__Group_6__0 ) ) | ( ( rule__PrimaryExpression__Group_7__0 ) ) | ( ( rule__PrimaryExpression__Group_8__0 ) ) | ( ( rule__PrimaryExpression__Group_9__0 ) ) );
    public final void rule__PrimaryExpression__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2158:1: ( ( ( rule__PrimaryExpression__Group_0__0 ) ) | ( ( rule__PrimaryExpression__Group_1__0 ) ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) | ( ( rule__PrimaryExpression__Group_3__0 ) ) | ( ( rule__PrimaryExpression__Group_4__0 ) ) | ( ( rule__PrimaryExpression__Group_5__0 ) ) | ( ( rule__PrimaryExpression__Group_6__0 ) ) | ( ( rule__PrimaryExpression__Group_7__0 ) ) | ( ( rule__PrimaryExpression__Group_8__0 ) ) | ( ( rule__PrimaryExpression__Group_9__0 ) ) )
            int alt11=10;
            alt11 = dfa11.predict(input);
            switch (alt11) {
                case 1 :
                    // InternalMickeyLang.g:2159:2: ( ( rule__PrimaryExpression__Group_0__0 ) )
                    {
                    // InternalMickeyLang.g:2159:2: ( ( rule__PrimaryExpression__Group_0__0 ) )
                    // InternalMickeyLang.g:2160:3: ( rule__PrimaryExpression__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_0()); 
                    }
                    // InternalMickeyLang.g:2161:3: ( rule__PrimaryExpression__Group_0__0 )
                    // InternalMickeyLang.g:2161:4: rule__PrimaryExpression__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2165:2: ( ( rule__PrimaryExpression__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:2165:2: ( ( rule__PrimaryExpression__Group_1__0 ) )
                    // InternalMickeyLang.g:2166:3: ( rule__PrimaryExpression__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:2167:3: ( rule__PrimaryExpression__Group_1__0 )
                    // InternalMickeyLang.g:2167:4: rule__PrimaryExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2171:2: ( ( rule__PrimaryExpression__Group_2__0 ) )
                    {
                    // InternalMickeyLang.g:2171:2: ( ( rule__PrimaryExpression__Group_2__0 ) )
                    // InternalMickeyLang.g:2172:3: ( rule__PrimaryExpression__Group_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); 
                    }
                    // InternalMickeyLang.g:2173:3: ( rule__PrimaryExpression__Group_2__0 )
                    // InternalMickeyLang.g:2173:4: rule__PrimaryExpression__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2177:2: ( ( rule__PrimaryExpression__Group_3__0 ) )
                    {
                    // InternalMickeyLang.g:2177:2: ( ( rule__PrimaryExpression__Group_3__0 ) )
                    // InternalMickeyLang.g:2178:3: ( rule__PrimaryExpression__Group_3__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_3()); 
                    }
                    // InternalMickeyLang.g:2179:3: ( rule__PrimaryExpression__Group_3__0 )
                    // InternalMickeyLang.g:2179:4: rule__PrimaryExpression__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2183:2: ( ( rule__PrimaryExpression__Group_4__0 ) )
                    {
                    // InternalMickeyLang.g:2183:2: ( ( rule__PrimaryExpression__Group_4__0 ) )
                    // InternalMickeyLang.g:2184:3: ( rule__PrimaryExpression__Group_4__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_4()); 
                    }
                    // InternalMickeyLang.g:2185:3: ( rule__PrimaryExpression__Group_4__0 )
                    // InternalMickeyLang.g:2185:4: rule__PrimaryExpression__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalMickeyLang.g:2189:2: ( ( rule__PrimaryExpression__Group_5__0 ) )
                    {
                    // InternalMickeyLang.g:2189:2: ( ( rule__PrimaryExpression__Group_5__0 ) )
                    // InternalMickeyLang.g:2190:3: ( rule__PrimaryExpression__Group_5__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_5()); 
                    }
                    // InternalMickeyLang.g:2191:3: ( rule__PrimaryExpression__Group_5__0 )
                    // InternalMickeyLang.g:2191:4: rule__PrimaryExpression__Group_5__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_5()); 
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalMickeyLang.g:2195:2: ( ( rule__PrimaryExpression__Group_6__0 ) )
                    {
                    // InternalMickeyLang.g:2195:2: ( ( rule__PrimaryExpression__Group_6__0 ) )
                    // InternalMickeyLang.g:2196:3: ( rule__PrimaryExpression__Group_6__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_6()); 
                    }
                    // InternalMickeyLang.g:2197:3: ( rule__PrimaryExpression__Group_6__0 )
                    // InternalMickeyLang.g:2197:4: rule__PrimaryExpression__Group_6__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_6__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_6()); 
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalMickeyLang.g:2201:2: ( ( rule__PrimaryExpression__Group_7__0 ) )
                    {
                    // InternalMickeyLang.g:2201:2: ( ( rule__PrimaryExpression__Group_7__0 ) )
                    // InternalMickeyLang.g:2202:3: ( rule__PrimaryExpression__Group_7__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_7()); 
                    }
                    // InternalMickeyLang.g:2203:3: ( rule__PrimaryExpression__Group_7__0 )
                    // InternalMickeyLang.g:2203:4: rule__PrimaryExpression__Group_7__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_7__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_7()); 
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalMickeyLang.g:2207:2: ( ( rule__PrimaryExpression__Group_8__0 ) )
                    {
                    // InternalMickeyLang.g:2207:2: ( ( rule__PrimaryExpression__Group_8__0 ) )
                    // InternalMickeyLang.g:2208:3: ( rule__PrimaryExpression__Group_8__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_8()); 
                    }
                    // InternalMickeyLang.g:2209:3: ( rule__PrimaryExpression__Group_8__0 )
                    // InternalMickeyLang.g:2209:4: rule__PrimaryExpression__Group_8__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_8__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_8()); 
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalMickeyLang.g:2213:2: ( ( rule__PrimaryExpression__Group_9__0 ) )
                    {
                    // InternalMickeyLang.g:2213:2: ( ( rule__PrimaryExpression__Group_9__0 ) )
                    // InternalMickeyLang.g:2214:3: ( rule__PrimaryExpression__Group_9__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_9()); 
                    }
                    // InternalMickeyLang.g:2215:3: ( rule__PrimaryExpression__Group_9__0 )
                    // InternalMickeyLang.g:2215:4: rule__PrimaryExpression__Group_9__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_9__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_9()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Alternatives"


    // $ANTLR start "rule__PrimaryExpression__Alternatives_2_1"
    // InternalMickeyLang.g:2223:1: rule__PrimaryExpression__Alternatives_2_1 : ( ( ( rule__PrimaryExpression__Group_2_1_0__0 ) ) | ( ( rule__PrimaryExpression__Group_2_1_1__0 ) ) | ( ( rule__PrimaryExpression__ColumnAssignment_2_1_2 ) ) );
    public final void rule__PrimaryExpression__Alternatives_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2227:1: ( ( ( rule__PrimaryExpression__Group_2_1_0__0 ) ) | ( ( rule__PrimaryExpression__Group_2_1_1__0 ) ) | ( ( rule__PrimaryExpression__ColumnAssignment_2_1_2 ) ) )
            int alt12=3;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==RULE_ID) ) {
                int LA12_1 = input.LA(2);

                if ( (LA12_1==77) ) {
                    switch ( input.LA(3) ) {
                    case 12:
                        {
                        switch ( input.LA(4) ) {
                        case EOF:
                        case 12:
                        case 13:
                        case 14:
                        case 15:
                        case 17:
                        case 18:
                        case 19:
                        case 20:
                        case 21:
                        case 22:
                        case 23:
                        case 24:
                        case 25:
                        case 26:
                        case 27:
                        case 28:
                        case 29:
                        case 30:
                        case 31:
                        case 32:
                        case 33:
                        case 34:
                        case 35:
                        case 36:
                        case 37:
                        case 38:
                        case 39:
                        case 40:
                        case 45:
                        case 46:
                        case 47:
                        case 48:
                        case 61:
                        case 63:
                        case 67:
                        case 68:
                        case 72:
                        case 73:
                        case 74:
                        case 79:
                        case 80:
                        case 82:
                        case 84:
                        case 85:
                        case 86:
                        case 87:
                        case 89:
                        case 90:
                        case 91:
                        case 92:
                        case 93:
                        case 97:
                        case 99:
                        case 102:
                        case 114:
                        case 118:
                        case 119:
                        case 124:
                        case 125:
                        case 126:
                        case 127:
                        case 129:
                        case 130:
                            {
                            alt12=2;
                            }
                            break;
                        case 16:
                            {
                            int LA12_7 = input.LA(5);

                            if ( ((LA12_7>=RULE_ID && LA12_7<=RULE_STRING)||LA12_7==16||LA12_7==62||(LA12_7>=75 && LA12_7<=76)||LA12_7==78||LA12_7==81||LA12_7==83||(LA12_7>=120 && LA12_7<=121)||(LA12_7>=131 && LA12_7<=134)) ) {
                                alt12=2;
                            }
                            else if ( (LA12_7==RULE_NUMBER) ) {
                                int LA12_8 = input.LA(6);

                                if ( (synpred37_InternalMickeyLang()) ) {
                                    alt12=1;
                                }
                                else if ( (synpred38_InternalMickeyLang()) ) {
                                    alt12=2;
                                }
                                else {
                                    if (state.backtracking>0) {state.failed=true; return ;}
                                    NoViableAltException nvae =
                                        new NoViableAltException("", 12, 8, input);

                                    throw nvae;
                                }
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return ;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 12, 7, input);

                                throw nvae;
                            }
                            }
                            break;
                        case RULE_NUMBER:
                        case RULE_ID:
                        case RULE_STRING:
                        case 62:
                        case 75:
                        case 76:
                        case 78:
                        case 81:
                        case 83:
                        case 120:
                        case 121:
                        case 131:
                        case 132:
                        case 133:
                        case 134:
                            {
                            alt12=1;
                            }
                            break;
                        default:
                            if (state.backtracking>0) {state.failed=true; return ;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 12, 4, input);

                            throw nvae;
                        }

                        }
                        break;
                    case RULE_ID:
                        {
                        alt12=2;
                        }
                        break;
                    case EOF:
                    case 13:
                    case 14:
                    case 15:
                    case 16:
                    case 17:
                    case 18:
                    case 19:
                    case 20:
                    case 21:
                    case 22:
                    case 23:
                    case 24:
                    case 25:
                    case 26:
                    case 27:
                    case 28:
                    case 29:
                    case 30:
                    case 31:
                    case 32:
                    case 33:
                    case 34:
                    case 35:
                    case 36:
                    case 37:
                    case 38:
                    case 39:
                    case 40:
                    case 45:
                    case 46:
                    case 47:
                    case 48:
                    case 61:
                    case 63:
                    case 67:
                    case 68:
                    case 72:
                    case 73:
                    case 74:
                    case 79:
                    case 80:
                    case 82:
                    case 84:
                    case 85:
                    case 86:
                    case 87:
                    case 89:
                    case 90:
                    case 91:
                    case 92:
                    case 93:
                    case 97:
                    case 99:
                    case 102:
                    case 114:
                    case 118:
                    case 119:
                    case 124:
                    case 125:
                    case 126:
                    case 127:
                    case 129:
                    case 130:
                        {
                        alt12=1;
                        }
                        break;
                    default:
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 12, 2, input);

                        throw nvae;
                    }

                }
                else if ( (LA12_1==EOF||(LA12_1>=12 && LA12_1<=40)||(LA12_1>=45 && LA12_1<=48)||LA12_1==61||LA12_1==63||(LA12_1>=67 && LA12_1<=68)||(LA12_1>=72 && LA12_1<=74)||(LA12_1>=79 && LA12_1<=80)||LA12_1==82||(LA12_1>=84 && LA12_1<=87)||(LA12_1>=89 && LA12_1<=93)||LA12_1==97||LA12_1==99||LA12_1==102||LA12_1==114||(LA12_1>=118 && LA12_1<=119)||(LA12_1>=124 && LA12_1<=127)||(LA12_1>=129 && LA12_1<=130)) ) {
                    alt12=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // InternalMickeyLang.g:2228:2: ( ( rule__PrimaryExpression__Group_2_1_0__0 ) )
                    {
                    // InternalMickeyLang.g:2228:2: ( ( rule__PrimaryExpression__Group_2_1_0__0 ) )
                    // InternalMickeyLang.g:2229:3: ( rule__PrimaryExpression__Group_2_1_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1_0()); 
                    }
                    // InternalMickeyLang.g:2230:3: ( rule__PrimaryExpression__Group_2_1_0__0 )
                    // InternalMickeyLang.g:2230:4: rule__PrimaryExpression__Group_2_1_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_2_1_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2234:2: ( ( rule__PrimaryExpression__Group_2_1_1__0 ) )
                    {
                    // InternalMickeyLang.g:2234:2: ( ( rule__PrimaryExpression__Group_2_1_1__0 ) )
                    // InternalMickeyLang.g:2235:3: ( rule__PrimaryExpression__Group_2_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1_1()); 
                    }
                    // InternalMickeyLang.g:2236:3: ( rule__PrimaryExpression__Group_2_1_1__0 )
                    // InternalMickeyLang.g:2236:4: rule__PrimaryExpression__Group_2_1_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_2_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2240:2: ( ( rule__PrimaryExpression__ColumnAssignment_2_1_2 ) )
                    {
                    // InternalMickeyLang.g:2240:2: ( ( rule__PrimaryExpression__ColumnAssignment_2_1_2 ) )
                    // InternalMickeyLang.g:2241:3: ( rule__PrimaryExpression__ColumnAssignment_2_1_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_2_1_2()); 
                    }
                    // InternalMickeyLang.g:2242:3: ( rule__PrimaryExpression__ColumnAssignment_2_1_2 )
                    // InternalMickeyLang.g:2242:4: rule__PrimaryExpression__ColumnAssignment_2_1_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__ColumnAssignment_2_1_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_2_1_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Alternatives_2_1"


    // $ANTLR start "rule__PrimaryExpression__Alternatives_2_1_1_2"
    // InternalMickeyLang.g:2250:1: rule__PrimaryExpression__Alternatives_2_1_1_2 : ( ( ( rule__PrimaryExpression__AllAssignment_2_1_1_2_0 ) ) | ( ( rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 ) ) );
    public final void rule__PrimaryExpression__Alternatives_2_1_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2254:1: ( ( ( rule__PrimaryExpression__AllAssignment_2_1_1_2_0 ) ) | ( ( rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 ) ) )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==12) ) {
                alt13=1;
            }
            else if ( (LA13_0==RULE_ID) ) {
                alt13=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }
            switch (alt13) {
                case 1 :
                    // InternalMickeyLang.g:2255:2: ( ( rule__PrimaryExpression__AllAssignment_2_1_1_2_0 ) )
                    {
                    // InternalMickeyLang.g:2255:2: ( ( rule__PrimaryExpression__AllAssignment_2_1_1_2_0 ) )
                    // InternalMickeyLang.g:2256:3: ( rule__PrimaryExpression__AllAssignment_2_1_1_2_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getAllAssignment_2_1_1_2_0()); 
                    }
                    // InternalMickeyLang.g:2257:3: ( rule__PrimaryExpression__AllAssignment_2_1_1_2_0 )
                    // InternalMickeyLang.g:2257:4: rule__PrimaryExpression__AllAssignment_2_1_1_2_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__AllAssignment_2_1_1_2_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getAllAssignment_2_1_1_2_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2261:2: ( ( rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 ) )
                    {
                    // InternalMickeyLang.g:2261:2: ( ( rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 ) )
                    // InternalMickeyLang.g:2262:3: ( rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_2_1_1_2_1()); 
                    }
                    // InternalMickeyLang.g:2263:3: ( rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 )
                    // InternalMickeyLang.g:2263:4: rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_2_1_1_2_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Alternatives_2_1_1_2"


    // $ANTLR start "rule__PrimaryExpression__Alternatives_7_3"
    // InternalMickeyLang.g:2271:1: rule__PrimaryExpression__Alternatives_7_3 : ( ( ( rule__PrimaryExpression__AllAssignment_7_3_0 ) ) | ( ( rule__PrimaryExpression__Group_7_3_1__0 ) ) );
    public final void rule__PrimaryExpression__Alternatives_7_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2275:1: ( ( ( rule__PrimaryExpression__AllAssignment_7_3_0 ) ) | ( ( rule__PrimaryExpression__Group_7_3_1__0 ) ) )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==12) ) {
                alt14=1;
            }
            else if ( ((LA14_0>=RULE_NUMBER && LA14_0<=RULE_STRING)||LA14_0==16||LA14_0==62||(LA14_0>=75 && LA14_0<=76)||LA14_0==78||LA14_0==81||LA14_0==83||(LA14_0>=120 && LA14_0<=121)||(LA14_0>=131 && LA14_0<=134)) ) {
                alt14=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // InternalMickeyLang.g:2276:2: ( ( rule__PrimaryExpression__AllAssignment_7_3_0 ) )
                    {
                    // InternalMickeyLang.g:2276:2: ( ( rule__PrimaryExpression__AllAssignment_7_3_0 ) )
                    // InternalMickeyLang.g:2277:3: ( rule__PrimaryExpression__AllAssignment_7_3_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getAllAssignment_7_3_0()); 
                    }
                    // InternalMickeyLang.g:2278:3: ( rule__PrimaryExpression__AllAssignment_7_3_0 )
                    // InternalMickeyLang.g:2278:4: rule__PrimaryExpression__AllAssignment_7_3_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__AllAssignment_7_3_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getAllAssignment_7_3_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2282:2: ( ( rule__PrimaryExpression__Group_7_3_1__0 ) )
                    {
                    // InternalMickeyLang.g:2282:2: ( ( rule__PrimaryExpression__Group_7_3_1__0 ) )
                    // InternalMickeyLang.g:2283:3: ( rule__PrimaryExpression__Group_7_3_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpressionAccess().getGroup_7_3_1()); 
                    }
                    // InternalMickeyLang.g:2284:3: ( rule__PrimaryExpression__Group_7_3_1__0 )
                    // InternalMickeyLang.g:2284:4: rule__PrimaryExpression__Group_7_3_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_7_3_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpressionAccess().getGroup_7_3_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Alternatives_7_3"


    // $ANTLR start "rule__SelectStatement__Alternatives_2_2_0"
    // InternalMickeyLang.g:2292:1: rule__SelectStatement__Alternatives_2_2_0 : ( ( 'offset' ) | ( ',' ) );
    public final void rule__SelectStatement__Alternatives_2_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2296:1: ( ( 'offset' ) | ( ',' ) )
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==39) ) {
                alt15=1;
            }
            else if ( (LA15_0==40) ) {
                alt15=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }
            switch (alt15) {
                case 1 :
                    // InternalMickeyLang.g:2297:2: ( 'offset' )
                    {
                    // InternalMickeyLang.g:2297:2: ( 'offset' )
                    // InternalMickeyLang.g:2298:3: 'offset'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSelectStatementAccess().getOffsetKeyword_2_2_0_0()); 
                    }
                    match(input,39,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSelectStatementAccess().getOffsetKeyword_2_2_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2303:2: ( ',' )
                    {
                    // InternalMickeyLang.g:2303:2: ( ',' )
                    // InternalMickeyLang.g:2304:3: ','
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSelectStatementAccess().getCommaKeyword_2_2_0_1()); 
                    }
                    match(input,40,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSelectStatementAccess().getCommaKeyword_2_2_0_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Alternatives_2_2_0"


    // $ANTLR start "rule__SelectExpression__Alternatives_2"
    // InternalMickeyLang.g:2313:1: rule__SelectExpression__Alternatives_2 : ( ( ( rule__SelectExpression__DistinctAssignment_2_0 ) ) | ( ( rule__SelectExpression__AllAssignment_2_1 ) ) );
    public final void rule__SelectExpression__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2317:1: ( ( ( rule__SelectExpression__DistinctAssignment_2_0 ) ) | ( ( rule__SelectExpression__AllAssignment_2_1 ) ) )
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0==122) ) {
                alt16=1;
            }
            else if ( (LA16_0==123) ) {
                alt16=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }
            switch (alt16) {
                case 1 :
                    // InternalMickeyLang.g:2318:2: ( ( rule__SelectExpression__DistinctAssignment_2_0 ) )
                    {
                    // InternalMickeyLang.g:2318:2: ( ( rule__SelectExpression__DistinctAssignment_2_0 ) )
                    // InternalMickeyLang.g:2319:3: ( rule__SelectExpression__DistinctAssignment_2_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSelectExpressionAccess().getDistinctAssignment_2_0()); 
                    }
                    // InternalMickeyLang.g:2320:3: ( rule__SelectExpression__DistinctAssignment_2_0 )
                    // InternalMickeyLang.g:2320:4: rule__SelectExpression__DistinctAssignment_2_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__DistinctAssignment_2_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSelectExpressionAccess().getDistinctAssignment_2_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2324:2: ( ( rule__SelectExpression__AllAssignment_2_1 ) )
                    {
                    // InternalMickeyLang.g:2324:2: ( ( rule__SelectExpression__AllAssignment_2_1 ) )
                    // InternalMickeyLang.g:2325:3: ( rule__SelectExpression__AllAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSelectExpressionAccess().getAllAssignment_2_1()); 
                    }
                    // InternalMickeyLang.g:2326:3: ( rule__SelectExpression__AllAssignment_2_1 )
                    // InternalMickeyLang.g:2326:4: rule__SelectExpression__AllAssignment_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__AllAssignment_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSelectExpressionAccess().getAllAssignment_2_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Alternatives_2"


    // $ANTLR start "rule__SelectExpression__Alternatives_3"
    // InternalMickeyLang.g:2334:1: rule__SelectExpression__Alternatives_3 : ( ( ( rule__SelectExpression__AllColumnsAssignment_3_0 ) ) | ( ( rule__SelectExpression__SelectListAssignment_3_1 ) ) );
    public final void rule__SelectExpression__Alternatives_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2338:1: ( ( ( rule__SelectExpression__AllColumnsAssignment_3_0 ) ) | ( ( rule__SelectExpression__SelectListAssignment_3_1 ) ) )
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==12) ) {
                alt17=1;
            }
            else if ( ((LA17_0>=RULE_NUMBER && LA17_0<=RULE_STRING)||LA17_0==16||LA17_0==62||(LA17_0>=75 && LA17_0<=76)||LA17_0==78||LA17_0==81||LA17_0==83||(LA17_0>=120 && LA17_0<=121)||(LA17_0>=131 && LA17_0<=134)) ) {
                alt17=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }
            switch (alt17) {
                case 1 :
                    // InternalMickeyLang.g:2339:2: ( ( rule__SelectExpression__AllColumnsAssignment_3_0 ) )
                    {
                    // InternalMickeyLang.g:2339:2: ( ( rule__SelectExpression__AllColumnsAssignment_3_0 ) )
                    // InternalMickeyLang.g:2340:3: ( rule__SelectExpression__AllColumnsAssignment_3_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSelectExpressionAccess().getAllColumnsAssignment_3_0()); 
                    }
                    // InternalMickeyLang.g:2341:3: ( rule__SelectExpression__AllColumnsAssignment_3_0 )
                    // InternalMickeyLang.g:2341:4: rule__SelectExpression__AllColumnsAssignment_3_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__AllColumnsAssignment_3_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSelectExpressionAccess().getAllColumnsAssignment_3_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2345:2: ( ( rule__SelectExpression__SelectListAssignment_3_1 ) )
                    {
                    // InternalMickeyLang.g:2345:2: ( ( rule__SelectExpression__SelectListAssignment_3_1 ) )
                    // InternalMickeyLang.g:2346:3: ( rule__SelectExpression__SelectListAssignment_3_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSelectExpressionAccess().getSelectListAssignment_3_1()); 
                    }
                    // InternalMickeyLang.g:2347:3: ( rule__SelectExpression__SelectListAssignment_3_1 )
                    // InternalMickeyLang.g:2347:4: rule__SelectExpression__SelectListAssignment_3_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__SelectListAssignment_3_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSelectExpressionAccess().getSelectListAssignment_3_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Alternatives_3"


    // $ANTLR start "rule__OrderingTerm__Alternatives_1"
    // InternalMickeyLang.g:2355:1: rule__OrderingTerm__Alternatives_1 : ( ( ( rule__OrderingTerm__AscAssignment_1_0 ) ) | ( ( rule__OrderingTerm__DescAssignment_1_1 ) ) );
    public final void rule__OrderingTerm__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2359:1: ( ( ( rule__OrderingTerm__AscAssignment_1_0 ) ) | ( ( rule__OrderingTerm__DescAssignment_1_1 ) ) )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==124) ) {
                alt18=1;
            }
            else if ( (LA18_0==125) ) {
                alt18=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }
            switch (alt18) {
                case 1 :
                    // InternalMickeyLang.g:2360:2: ( ( rule__OrderingTerm__AscAssignment_1_0 ) )
                    {
                    // InternalMickeyLang.g:2360:2: ( ( rule__OrderingTerm__AscAssignment_1_0 ) )
                    // InternalMickeyLang.g:2361:3: ( rule__OrderingTerm__AscAssignment_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOrderingTermAccess().getAscAssignment_1_0()); 
                    }
                    // InternalMickeyLang.g:2362:3: ( rule__OrderingTerm__AscAssignment_1_0 )
                    // InternalMickeyLang.g:2362:4: rule__OrderingTerm__AscAssignment_1_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__OrderingTerm__AscAssignment_1_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOrderingTermAccess().getAscAssignment_1_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2366:2: ( ( rule__OrderingTerm__DescAssignment_1_1 ) )
                    {
                    // InternalMickeyLang.g:2366:2: ( ( rule__OrderingTerm__DescAssignment_1_1 ) )
                    // InternalMickeyLang.g:2367:3: ( rule__OrderingTerm__DescAssignment_1_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOrderingTermAccess().getDescAssignment_1_1()); 
                    }
                    // InternalMickeyLang.g:2368:3: ( rule__OrderingTerm__DescAssignment_1_1 )
                    // InternalMickeyLang.g:2368:4: rule__OrderingTerm__DescAssignment_1_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__OrderingTerm__DescAssignment_1_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOrderingTermAccess().getDescAssignment_1_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__Alternatives_1"


    // $ANTLR start "rule__SingleSource__Alternatives"
    // InternalMickeyLang.g:2376:1: rule__SingleSource__Alternatives : ( ( ruleSingleSourceTable ) | ( ruleSingleSourceSelectStatement ) | ( ruleSingleSourceJoin ) );
    public final void rule__SingleSource__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2380:1: ( ( ruleSingleSourceTable ) | ( ruleSingleSourceSelectStatement ) | ( ruleSingleSourceJoin ) )
            int alt19=3;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==RULE_ID) ) {
                alt19=1;
            }
            else if ( (LA19_0==62) ) {
                int LA19_2 = input.LA(2);

                if ( (LA19_2==RULE_ID||LA19_2==62) ) {
                    alt19=3;
                }
                else if ( (LA19_2==88) ) {
                    alt19=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 19, 2, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                throw nvae;
            }
            switch (alt19) {
                case 1 :
                    // InternalMickeyLang.g:2381:2: ( ruleSingleSourceTable )
                    {
                    // InternalMickeyLang.g:2381:2: ( ruleSingleSourceTable )
                    // InternalMickeyLang.g:2382:3: ruleSingleSourceTable
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSingleSourceAccess().getSingleSourceTableParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleSingleSourceTable();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSingleSourceAccess().getSingleSourceTableParserRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2387:2: ( ruleSingleSourceSelectStatement )
                    {
                    // InternalMickeyLang.g:2387:2: ( ruleSingleSourceSelectStatement )
                    // InternalMickeyLang.g:2388:3: ruleSingleSourceSelectStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSingleSourceAccess().getSingleSourceSelectStatementParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleSingleSourceSelectStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSingleSourceAccess().getSingleSourceSelectStatementParserRuleCall_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2393:2: ( ruleSingleSourceJoin )
                    {
                    // InternalMickeyLang.g:2393:2: ( ruleSingleSourceJoin )
                    // InternalMickeyLang.g:2394:3: ruleSingleSourceJoin
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSingleSourceAccess().getSingleSourceJoinParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleSingleSourceJoin();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSingleSourceAccess().getSingleSourceJoinParserRuleCall_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSource__Alternatives"


    // $ANTLR start "rule__JoinStatement__Alternatives_2"
    // InternalMickeyLang.g:2403:1: rule__JoinStatement__Alternatives_2 : ( ( ( rule__JoinStatement__Group_2_0__0 ) ) | ( ( rule__JoinStatement__InnerAssignment_2_1 ) ) | ( ( rule__JoinStatement__CrossAssignment_2_2 ) ) );
    public final void rule__JoinStatement__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2407:1: ( ( ( rule__JoinStatement__Group_2_0__0 ) ) | ( ( rule__JoinStatement__InnerAssignment_2_1 ) ) | ( ( rule__JoinStatement__CrossAssignment_2_2 ) ) )
            int alt20=3;
            switch ( input.LA(1) ) {
            case 127:
                {
                alt20=1;
                }
                break;
            case 129:
                {
                alt20=2;
                }
                break;
            case 130:
                {
                alt20=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }

            switch (alt20) {
                case 1 :
                    // InternalMickeyLang.g:2408:2: ( ( rule__JoinStatement__Group_2_0__0 ) )
                    {
                    // InternalMickeyLang.g:2408:2: ( ( rule__JoinStatement__Group_2_0__0 ) )
                    // InternalMickeyLang.g:2409:3: ( rule__JoinStatement__Group_2_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getJoinStatementAccess().getGroup_2_0()); 
                    }
                    // InternalMickeyLang.g:2410:3: ( rule__JoinStatement__Group_2_0__0 )
                    // InternalMickeyLang.g:2410:4: rule__JoinStatement__Group_2_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__JoinStatement__Group_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getJoinStatementAccess().getGroup_2_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2414:2: ( ( rule__JoinStatement__InnerAssignment_2_1 ) )
                    {
                    // InternalMickeyLang.g:2414:2: ( ( rule__JoinStatement__InnerAssignment_2_1 ) )
                    // InternalMickeyLang.g:2415:3: ( rule__JoinStatement__InnerAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getJoinStatementAccess().getInnerAssignment_2_1()); 
                    }
                    // InternalMickeyLang.g:2416:3: ( rule__JoinStatement__InnerAssignment_2_1 )
                    // InternalMickeyLang.g:2416:4: rule__JoinStatement__InnerAssignment_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__JoinStatement__InnerAssignment_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getJoinStatementAccess().getInnerAssignment_2_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2420:2: ( ( rule__JoinStatement__CrossAssignment_2_2 ) )
                    {
                    // InternalMickeyLang.g:2420:2: ( ( rule__JoinStatement__CrossAssignment_2_2 ) )
                    // InternalMickeyLang.g:2421:3: ( rule__JoinStatement__CrossAssignment_2_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getJoinStatementAccess().getCrossAssignment_2_2()); 
                    }
                    // InternalMickeyLang.g:2422:3: ( rule__JoinStatement__CrossAssignment_2_2 )
                    // InternalMickeyLang.g:2422:4: rule__JoinStatement__CrossAssignment_2_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__JoinStatement__CrossAssignment_2_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getJoinStatementAccess().getCrossAssignment_2_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Alternatives_2"


    // $ANTLR start "rule__LiteralValue__Alternatives"
    // InternalMickeyLang.g:2430:1: rule__LiteralValue__Alternatives : ( ( ( rule__LiteralValue__Group_0__0 ) ) | ( ( rule__LiteralValue__Group_1__0 ) ) | ( ( rule__LiteralValue__Group_2__0 ) ) | ( ( rule__LiteralValue__Group_3__0 ) ) | ( ( rule__LiteralValue__Group_4__0 ) ) | ( ( rule__LiteralValue__Group_5__0 ) ) );
    public final void rule__LiteralValue__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2434:1: ( ( ( rule__LiteralValue__Group_0__0 ) ) | ( ( rule__LiteralValue__Group_1__0 ) ) | ( ( rule__LiteralValue__Group_2__0 ) ) | ( ( rule__LiteralValue__Group_3__0 ) ) | ( ( rule__LiteralValue__Group_4__0 ) ) | ( ( rule__LiteralValue__Group_5__0 ) ) )
            int alt21=6;
            switch ( input.LA(1) ) {
            case RULE_NUMBER:
            case 16:
                {
                alt21=1;
                }
                break;
            case RULE_STRING:
                {
                alt21=2;
                }
                break;
            case 131:
                {
                alt21=3;
                }
                break;
            case 132:
                {
                alt21=4;
                }
                break;
            case 133:
                {
                alt21=5;
                }
                break;
            case 134:
                {
                alt21=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;
            }

            switch (alt21) {
                case 1 :
                    // InternalMickeyLang.g:2435:2: ( ( rule__LiteralValue__Group_0__0 ) )
                    {
                    // InternalMickeyLang.g:2435:2: ( ( rule__LiteralValue__Group_0__0 ) )
                    // InternalMickeyLang.g:2436:3: ( rule__LiteralValue__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralValueAccess().getGroup_0()); 
                    }
                    // InternalMickeyLang.g:2437:3: ( rule__LiteralValue__Group_0__0 )
                    // InternalMickeyLang.g:2437:4: rule__LiteralValue__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LiteralValue__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getLiteralValueAccess().getGroup_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2441:2: ( ( rule__LiteralValue__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:2441:2: ( ( rule__LiteralValue__Group_1__0 ) )
                    // InternalMickeyLang.g:2442:3: ( rule__LiteralValue__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralValueAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:2443:3: ( rule__LiteralValue__Group_1__0 )
                    // InternalMickeyLang.g:2443:4: rule__LiteralValue__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LiteralValue__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getLiteralValueAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2447:2: ( ( rule__LiteralValue__Group_2__0 ) )
                    {
                    // InternalMickeyLang.g:2447:2: ( ( rule__LiteralValue__Group_2__0 ) )
                    // InternalMickeyLang.g:2448:3: ( rule__LiteralValue__Group_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralValueAccess().getGroup_2()); 
                    }
                    // InternalMickeyLang.g:2449:3: ( rule__LiteralValue__Group_2__0 )
                    // InternalMickeyLang.g:2449:4: rule__LiteralValue__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LiteralValue__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getLiteralValueAccess().getGroup_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2453:2: ( ( rule__LiteralValue__Group_3__0 ) )
                    {
                    // InternalMickeyLang.g:2453:2: ( ( rule__LiteralValue__Group_3__0 ) )
                    // InternalMickeyLang.g:2454:3: ( rule__LiteralValue__Group_3__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralValueAccess().getGroup_3()); 
                    }
                    // InternalMickeyLang.g:2455:3: ( rule__LiteralValue__Group_3__0 )
                    // InternalMickeyLang.g:2455:4: rule__LiteralValue__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LiteralValue__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getLiteralValueAccess().getGroup_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2459:2: ( ( rule__LiteralValue__Group_4__0 ) )
                    {
                    // InternalMickeyLang.g:2459:2: ( ( rule__LiteralValue__Group_4__0 ) )
                    // InternalMickeyLang.g:2460:3: ( rule__LiteralValue__Group_4__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralValueAccess().getGroup_4()); 
                    }
                    // InternalMickeyLang.g:2461:3: ( rule__LiteralValue__Group_4__0 )
                    // InternalMickeyLang.g:2461:4: rule__LiteralValue__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LiteralValue__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getLiteralValueAccess().getGroup_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalMickeyLang.g:2465:2: ( ( rule__LiteralValue__Group_5__0 ) )
                    {
                    // InternalMickeyLang.g:2465:2: ( ( rule__LiteralValue__Group_5__0 ) )
                    // InternalMickeyLang.g:2466:3: ( rule__LiteralValue__Group_5__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralValueAccess().getGroup_5()); 
                    }
                    // InternalMickeyLang.g:2467:3: ( rule__LiteralValue__Group_5__0 )
                    // InternalMickeyLang.g:2467:4: rule__LiteralValue__Group_5__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LiteralValue__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getLiteralValueAccess().getGroup_5()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Alternatives"


    // $ANTLR start "rule__DDLStatement__Alternatives"
    // InternalMickeyLang.g:2475:1: rule__DDLStatement__Alternatives : ( ( ruleCreateTableStatement ) | ( ruleCreateViewStatement ) | ( ruleCreateTriggerStatement ) | ( ruleCreateIndexStatement ) | ( ruleAlterTableRenameStatement ) | ( ruleAlterTableAddColumnStatement ) | ( ruleDropTableStatement ) | ( ruleDropTriggerStatement ) | ( ruleDropViewStatement ) | ( ruleDropIndexStatement ) );
    public final void rule__DDLStatement__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2479:1: ( ( ruleCreateTableStatement ) | ( ruleCreateViewStatement ) | ( ruleCreateTriggerStatement ) | ( ruleCreateIndexStatement ) | ( ruleAlterTableRenameStatement ) | ( ruleAlterTableAddColumnStatement ) | ( ruleDropTableStatement ) | ( ruleDropTriggerStatement ) | ( ruleDropViewStatement ) | ( ruleDropIndexStatement ) )
            int alt22=10;
            alt22 = dfa22.predict(input);
            switch (alt22) {
                case 1 :
                    // InternalMickeyLang.g:2480:2: ( ruleCreateTableStatement )
                    {
                    // InternalMickeyLang.g:2480:2: ( ruleCreateTableStatement )
                    // InternalMickeyLang.g:2481:3: ruleCreateTableStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getCreateTableStatementParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCreateTableStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getCreateTableStatementParserRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2486:2: ( ruleCreateViewStatement )
                    {
                    // InternalMickeyLang.g:2486:2: ( ruleCreateViewStatement )
                    // InternalMickeyLang.g:2487:3: ruleCreateViewStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getCreateViewStatementParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCreateViewStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getCreateViewStatementParserRuleCall_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2492:2: ( ruleCreateTriggerStatement )
                    {
                    // InternalMickeyLang.g:2492:2: ( ruleCreateTriggerStatement )
                    // InternalMickeyLang.g:2493:3: ruleCreateTriggerStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getCreateTriggerStatementParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCreateTriggerStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getCreateTriggerStatementParserRuleCall_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2498:2: ( ruleCreateIndexStatement )
                    {
                    // InternalMickeyLang.g:2498:2: ( ruleCreateIndexStatement )
                    // InternalMickeyLang.g:2499:3: ruleCreateIndexStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getCreateIndexStatementParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCreateIndexStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getCreateIndexStatementParserRuleCall_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2504:2: ( ruleAlterTableRenameStatement )
                    {
                    // InternalMickeyLang.g:2504:2: ( ruleAlterTableRenameStatement )
                    // InternalMickeyLang.g:2505:3: ruleAlterTableRenameStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getAlterTableRenameStatementParserRuleCall_4()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleAlterTableRenameStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getAlterTableRenameStatementParserRuleCall_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalMickeyLang.g:2510:2: ( ruleAlterTableAddColumnStatement )
                    {
                    // InternalMickeyLang.g:2510:2: ( ruleAlterTableAddColumnStatement )
                    // InternalMickeyLang.g:2511:3: ruleAlterTableAddColumnStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getAlterTableAddColumnStatementParserRuleCall_5()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleAlterTableAddColumnStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getAlterTableAddColumnStatementParserRuleCall_5()); 
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalMickeyLang.g:2516:2: ( ruleDropTableStatement )
                    {
                    // InternalMickeyLang.g:2516:2: ( ruleDropTableStatement )
                    // InternalMickeyLang.g:2517:3: ruleDropTableStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getDropTableStatementParserRuleCall_6()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleDropTableStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getDropTableStatementParserRuleCall_6()); 
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalMickeyLang.g:2522:2: ( ruleDropTriggerStatement )
                    {
                    // InternalMickeyLang.g:2522:2: ( ruleDropTriggerStatement )
                    // InternalMickeyLang.g:2523:3: ruleDropTriggerStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getDropTriggerStatementParserRuleCall_7()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleDropTriggerStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getDropTriggerStatementParserRuleCall_7()); 
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalMickeyLang.g:2528:2: ( ruleDropViewStatement )
                    {
                    // InternalMickeyLang.g:2528:2: ( ruleDropViewStatement )
                    // InternalMickeyLang.g:2529:3: ruleDropViewStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getDropViewStatementParserRuleCall_8()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleDropViewStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getDropViewStatementParserRuleCall_8()); 
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalMickeyLang.g:2534:2: ( ruleDropIndexStatement )
                    {
                    // InternalMickeyLang.g:2534:2: ( ruleDropIndexStatement )
                    // InternalMickeyLang.g:2535:3: ruleDropIndexStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDDLStatementAccess().getDropIndexStatementParserRuleCall_9()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleDropIndexStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDDLStatementAccess().getDropIndexStatementParserRuleCall_9()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DDLStatement__Alternatives"


    // $ANTLR start "rule__CreateTriggerStatement__WhenAlternatives_4_0"
    // InternalMickeyLang.g:2544:1: rule__CreateTriggerStatement__WhenAlternatives_4_0 : ( ( 'before' ) | ( 'after' ) | ( 'instead of' ) );
    public final void rule__CreateTriggerStatement__WhenAlternatives_4_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2548:1: ( ( 'before' ) | ( 'after' ) | ( 'instead of' ) )
            int alt23=3;
            switch ( input.LA(1) ) {
            case 41:
                {
                alt23=1;
                }
                break;
            case 42:
                {
                alt23=2;
                }
                break;
            case 43:
                {
                alt23=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }

            switch (alt23) {
                case 1 :
                    // InternalMickeyLang.g:2549:2: ( 'before' )
                    {
                    // InternalMickeyLang.g:2549:2: ( 'before' )
                    // InternalMickeyLang.g:2550:3: 'before'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCreateTriggerStatementAccess().getWhenBeforeKeyword_4_0_0()); 
                    }
                    match(input,41,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCreateTriggerStatementAccess().getWhenBeforeKeyword_4_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2555:2: ( 'after' )
                    {
                    // InternalMickeyLang.g:2555:2: ( 'after' )
                    // InternalMickeyLang.g:2556:3: 'after'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCreateTriggerStatementAccess().getWhenAfterKeyword_4_0_1()); 
                    }
                    match(input,42,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCreateTriggerStatementAccess().getWhenAfterKeyword_4_0_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2561:2: ( 'instead of' )
                    {
                    // InternalMickeyLang.g:2561:2: ( 'instead of' )
                    // InternalMickeyLang.g:2562:3: 'instead of'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCreateTriggerStatementAccess().getWhenInsteadOfKeyword_4_0_2()); 
                    }
                    match(input,43,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCreateTriggerStatementAccess().getWhenInsteadOfKeyword_4_0_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__WhenAlternatives_4_0"


    // $ANTLR start "rule__CreateTriggerStatement__Alternatives_5"
    // InternalMickeyLang.g:2571:1: rule__CreateTriggerStatement__Alternatives_5 : ( ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_0 ) ) | ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_1 ) ) | ( ( rule__CreateTriggerStatement__Group_5_2__0 ) ) );
    public final void rule__CreateTriggerStatement__Alternatives_5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2575:1: ( ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_0 ) ) | ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_1 ) ) | ( ( rule__CreateTriggerStatement__Group_5_2__0 ) ) )
            int alt24=3;
            switch ( input.LA(1) ) {
            case 111:
                {
                alt24=1;
                }
                break;
            case 113:
                {
                alt24=2;
                }
                break;
            case 116:
                {
                alt24=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                throw nvae;
            }

            switch (alt24) {
                case 1 :
                    // InternalMickeyLang.g:2576:2: ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_0 ) )
                    {
                    // InternalMickeyLang.g:2576:2: ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_0 ) )
                    // InternalMickeyLang.g:2577:3: ( rule__CreateTriggerStatement__EventTypeAssignment_5_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeAssignment_5_0()); 
                    }
                    // InternalMickeyLang.g:2578:3: ( rule__CreateTriggerStatement__EventTypeAssignment_5_0 )
                    // InternalMickeyLang.g:2578:4: rule__CreateTriggerStatement__EventTypeAssignment_5_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__EventTypeAssignment_5_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeAssignment_5_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2582:2: ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_1 ) )
                    {
                    // InternalMickeyLang.g:2582:2: ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_1 ) )
                    // InternalMickeyLang.g:2583:3: ( rule__CreateTriggerStatement__EventTypeAssignment_5_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeAssignment_5_1()); 
                    }
                    // InternalMickeyLang.g:2584:3: ( rule__CreateTriggerStatement__EventTypeAssignment_5_1 )
                    // InternalMickeyLang.g:2584:4: rule__CreateTriggerStatement__EventTypeAssignment_5_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__EventTypeAssignment_5_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeAssignment_5_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2588:2: ( ( rule__CreateTriggerStatement__Group_5_2__0 ) )
                    {
                    // InternalMickeyLang.g:2588:2: ( ( rule__CreateTriggerStatement__Group_5_2__0 ) )
                    // InternalMickeyLang.g:2589:3: ( rule__CreateTriggerStatement__Group_5_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCreateTriggerStatementAccess().getGroup_5_2()); 
                    }
                    // InternalMickeyLang.g:2590:3: ( rule__CreateTriggerStatement__Group_5_2__0 )
                    // InternalMickeyLang.g:2590:4: rule__CreateTriggerStatement__Group_5_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__Group_5_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCreateTriggerStatementAccess().getGroup_5_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Alternatives_5"


    // $ANTLR start "rule__ColumnConstraint__Alternatives"
    // InternalMickeyLang.g:2598:1: rule__ColumnConstraint__Alternatives : ( ( ( rule__ColumnConstraint__Group_0__0 ) ) | ( ( rule__ColumnConstraint__Group_1__0 ) ) | ( ( rule__ColumnConstraint__Group_2__0 ) ) | ( ( rule__ColumnConstraint__Group_3__0 ) ) | ( ( rule__ColumnConstraint__Group_4__0 ) ) );
    public final void rule__ColumnConstraint__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2602:1: ( ( ( rule__ColumnConstraint__Group_0__0 ) ) | ( ( rule__ColumnConstraint__Group_1__0 ) ) | ( ( rule__ColumnConstraint__Group_2__0 ) ) | ( ( rule__ColumnConstraint__Group_3__0 ) ) | ( ( rule__ColumnConstraint__Group_4__0 ) ) )
            int alt25=5;
            switch ( input.LA(1) ) {
            case 104:
                {
                alt25=1;
                }
                break;
            case 37:
                {
                alt25=2;
                }
                break;
            case 105:
                {
                alt25=3;
                }
                break;
            case 106:
                {
                alt25=4;
                }
                break;
            case 107:
                {
                alt25=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }

            switch (alt25) {
                case 1 :
                    // InternalMickeyLang.g:2603:2: ( ( rule__ColumnConstraint__Group_0__0 ) )
                    {
                    // InternalMickeyLang.g:2603:2: ( ( rule__ColumnConstraint__Group_0__0 ) )
                    // InternalMickeyLang.g:2604:3: ( rule__ColumnConstraint__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getGroup_0()); 
                    }
                    // InternalMickeyLang.g:2605:3: ( rule__ColumnConstraint__Group_0__0 )
                    // InternalMickeyLang.g:2605:4: rule__ColumnConstraint__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getGroup_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2609:2: ( ( rule__ColumnConstraint__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:2609:2: ( ( rule__ColumnConstraint__Group_1__0 ) )
                    // InternalMickeyLang.g:2610:3: ( rule__ColumnConstraint__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:2611:3: ( rule__ColumnConstraint__Group_1__0 )
                    // InternalMickeyLang.g:2611:4: rule__ColumnConstraint__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2615:2: ( ( rule__ColumnConstraint__Group_2__0 ) )
                    {
                    // InternalMickeyLang.g:2615:2: ( ( rule__ColumnConstraint__Group_2__0 ) )
                    // InternalMickeyLang.g:2616:3: ( rule__ColumnConstraint__Group_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getGroup_2()); 
                    }
                    // InternalMickeyLang.g:2617:3: ( rule__ColumnConstraint__Group_2__0 )
                    // InternalMickeyLang.g:2617:4: rule__ColumnConstraint__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getGroup_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2621:2: ( ( rule__ColumnConstraint__Group_3__0 ) )
                    {
                    // InternalMickeyLang.g:2621:2: ( ( rule__ColumnConstraint__Group_3__0 ) )
                    // InternalMickeyLang.g:2622:3: ( rule__ColumnConstraint__Group_3__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getGroup_3()); 
                    }
                    // InternalMickeyLang.g:2623:3: ( rule__ColumnConstraint__Group_3__0 )
                    // InternalMickeyLang.g:2623:4: rule__ColumnConstraint__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getGroup_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2627:2: ( ( rule__ColumnConstraint__Group_4__0 ) )
                    {
                    // InternalMickeyLang.g:2627:2: ( ( rule__ColumnConstraint__Group_4__0 ) )
                    // InternalMickeyLang.g:2628:3: ( rule__ColumnConstraint__Group_4__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getGroup_4()); 
                    }
                    // InternalMickeyLang.g:2629:3: ( rule__ColumnConstraint__Group_4__0 )
                    // InternalMickeyLang.g:2629:4: rule__ColumnConstraint__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getGroup_4()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Alternatives"


    // $ANTLR start "rule__ColumnConstraint__Alternatives_0_2"
    // InternalMickeyLang.g:2637:1: rule__ColumnConstraint__Alternatives_0_2 : ( ( ( rule__ColumnConstraint__AscAssignment_0_2_0 ) ) | ( ( rule__ColumnConstraint__DescAssignment_0_2_1 ) ) );
    public final void rule__ColumnConstraint__Alternatives_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2641:1: ( ( ( rule__ColumnConstraint__AscAssignment_0_2_0 ) ) | ( ( rule__ColumnConstraint__DescAssignment_0_2_1 ) ) )
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==124) ) {
                alt26=1;
            }
            else if ( (LA26_0==125) ) {
                alt26=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;
            }
            switch (alt26) {
                case 1 :
                    // InternalMickeyLang.g:2642:2: ( ( rule__ColumnConstraint__AscAssignment_0_2_0 ) )
                    {
                    // InternalMickeyLang.g:2642:2: ( ( rule__ColumnConstraint__AscAssignment_0_2_0 ) )
                    // InternalMickeyLang.g:2643:3: ( rule__ColumnConstraint__AscAssignment_0_2_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getAscAssignment_0_2_0()); 
                    }
                    // InternalMickeyLang.g:2644:3: ( rule__ColumnConstraint__AscAssignment_0_2_0 )
                    // InternalMickeyLang.g:2644:4: rule__ColumnConstraint__AscAssignment_0_2_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__AscAssignment_0_2_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getAscAssignment_0_2_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2648:2: ( ( rule__ColumnConstraint__DescAssignment_0_2_1 ) )
                    {
                    // InternalMickeyLang.g:2648:2: ( ( rule__ColumnConstraint__DescAssignment_0_2_1 ) )
                    // InternalMickeyLang.g:2649:3: ( rule__ColumnConstraint__DescAssignment_0_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnConstraintAccess().getDescAssignment_0_2_1()); 
                    }
                    // InternalMickeyLang.g:2650:3: ( rule__ColumnConstraint__DescAssignment_0_2_1 )
                    // InternalMickeyLang.g:2650:4: rule__ColumnConstraint__DescAssignment_0_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__DescAssignment_0_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnConstraintAccess().getDescAssignment_0_2_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Alternatives_0_2"


    // $ANTLR start "rule__TableConstraint__Alternatives"
    // InternalMickeyLang.g:2658:1: rule__TableConstraint__Alternatives : ( ( ruleUniqueTableConstraint ) | ( rulePrimaryConstraint ) | ( ruleCheckTableConstraint ) );
    public final void rule__TableConstraint__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2662:1: ( ( ruleUniqueTableConstraint ) | ( rulePrimaryConstraint ) | ( ruleCheckTableConstraint ) )
            int alt27=3;
            switch ( input.LA(1) ) {
            case 108:
                {
                int LA27_1 = input.LA(2);

                if ( (LA27_1==RULE_ID) ) {
                    switch ( input.LA(3) ) {
                    case 104:
                        {
                        alt27=2;
                        }
                        break;
                    case 107:
                        {
                        alt27=3;
                        }
                        break;
                    case 105:
                        {
                        alt27=1;
                        }
                        break;
                    default:
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 27, 5, input);

                        throw nvae;
                    }

                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 27, 1, input);

                    throw nvae;
                }
                }
                break;
            case 105:
                {
                alt27=1;
                }
                break;
            case 104:
                {
                alt27=2;
                }
                break;
            case 107:
                {
                alt27=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 27, 0, input);

                throw nvae;
            }

            switch (alt27) {
                case 1 :
                    // InternalMickeyLang.g:2663:2: ( ruleUniqueTableConstraint )
                    {
                    // InternalMickeyLang.g:2663:2: ( ruleUniqueTableConstraint )
                    // InternalMickeyLang.g:2664:3: ruleUniqueTableConstraint
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTableConstraintAccess().getUniqueTableConstraintParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleUniqueTableConstraint();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTableConstraintAccess().getUniqueTableConstraintParserRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2669:2: ( rulePrimaryConstraint )
                    {
                    // InternalMickeyLang.g:2669:2: ( rulePrimaryConstraint )
                    // InternalMickeyLang.g:2670:3: rulePrimaryConstraint
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTableConstraintAccess().getPrimaryConstraintParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    rulePrimaryConstraint();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTableConstraintAccess().getPrimaryConstraintParserRuleCall_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2675:2: ( ruleCheckTableConstraint )
                    {
                    // InternalMickeyLang.g:2675:2: ( ruleCheckTableConstraint )
                    // InternalMickeyLang.g:2676:3: ruleCheckTableConstraint
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTableConstraintAccess().getCheckTableConstraintParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCheckTableConstraint();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTableConstraintAccess().getCheckTableConstraintParserRuleCall_2()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TableConstraint__Alternatives"


    // $ANTLR start "rule__IndexedColumn__Alternatives_2"
    // InternalMickeyLang.g:2685:1: rule__IndexedColumn__Alternatives_2 : ( ( ( rule__IndexedColumn__AscAssignment_2_0 ) ) | ( ( rule__IndexedColumn__DescAssignment_2_1 ) ) );
    public final void rule__IndexedColumn__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2689:1: ( ( ( rule__IndexedColumn__AscAssignment_2_0 ) ) | ( ( rule__IndexedColumn__DescAssignment_2_1 ) ) )
            int alt28=2;
            int LA28_0 = input.LA(1);

            if ( (LA28_0==124) ) {
                alt28=1;
            }
            else if ( (LA28_0==125) ) {
                alt28=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                throw nvae;
            }
            switch (alt28) {
                case 1 :
                    // InternalMickeyLang.g:2690:2: ( ( rule__IndexedColumn__AscAssignment_2_0 ) )
                    {
                    // InternalMickeyLang.g:2690:2: ( ( rule__IndexedColumn__AscAssignment_2_0 ) )
                    // InternalMickeyLang.g:2691:3: ( rule__IndexedColumn__AscAssignment_2_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIndexedColumnAccess().getAscAssignment_2_0()); 
                    }
                    // InternalMickeyLang.g:2692:3: ( rule__IndexedColumn__AscAssignment_2_0 )
                    // InternalMickeyLang.g:2692:4: rule__IndexedColumn__AscAssignment_2_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__IndexedColumn__AscAssignment_2_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIndexedColumnAccess().getAscAssignment_2_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2696:2: ( ( rule__IndexedColumn__DescAssignment_2_1 ) )
                    {
                    // InternalMickeyLang.g:2696:2: ( ( rule__IndexedColumn__DescAssignment_2_1 ) )
                    // InternalMickeyLang.g:2697:3: ( rule__IndexedColumn__DescAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIndexedColumnAccess().getDescAssignment_2_1()); 
                    }
                    // InternalMickeyLang.g:2698:3: ( rule__IndexedColumn__DescAssignment_2_1 )
                    // InternalMickeyLang.g:2698:4: rule__IndexedColumn__DescAssignment_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__IndexedColumn__DescAssignment_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIndexedColumnAccess().getDescAssignment_2_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Alternatives_2"


    // $ANTLR start "rule__DefaultValue__Alternatives"
    // InternalMickeyLang.g:2706:1: rule__DefaultValue__Alternatives : ( ( ( rule__DefaultValue__Group_0__0 ) ) | ( ( rule__DefaultValue__Group_1__0 ) ) );
    public final void rule__DefaultValue__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2710:1: ( ( ( rule__DefaultValue__Group_0__0 ) ) | ( ( rule__DefaultValue__Group_1__0 ) ) )
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==RULE_NUMBER||LA29_0==RULE_STRING||LA29_0==16||(LA29_0>=131 && LA29_0<=134)) ) {
                alt29=1;
            }
            else if ( (LA29_0==62) ) {
                alt29=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }
            switch (alt29) {
                case 1 :
                    // InternalMickeyLang.g:2711:2: ( ( rule__DefaultValue__Group_0__0 ) )
                    {
                    // InternalMickeyLang.g:2711:2: ( ( rule__DefaultValue__Group_0__0 ) )
                    // InternalMickeyLang.g:2712:3: ( rule__DefaultValue__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDefaultValueAccess().getGroup_0()); 
                    }
                    // InternalMickeyLang.g:2713:3: ( rule__DefaultValue__Group_0__0 )
                    // InternalMickeyLang.g:2713:4: rule__DefaultValue__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__DefaultValue__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDefaultValueAccess().getGroup_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2717:2: ( ( rule__DefaultValue__Group_1__0 ) )
                    {
                    // InternalMickeyLang.g:2717:2: ( ( rule__DefaultValue__Group_1__0 ) )
                    // InternalMickeyLang.g:2718:3: ( rule__DefaultValue__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDefaultValueAccess().getGroup_1()); 
                    }
                    // InternalMickeyLang.g:2719:3: ( rule__DefaultValue__Group_1__0 )
                    // InternalMickeyLang.g:2719:4: rule__DefaultValue__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__DefaultValue__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDefaultValueAccess().getGroup_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Alternatives"


    // $ANTLR start "rule__DMLStatement__Alternatives"
    // InternalMickeyLang.g:2727:1: rule__DMLStatement__Alternatives : ( ( ruleSelectStatement ) | ( ruleInsertStatement ) | ( ruleUpdateStatement ) | ( ruleDeleteStatement ) );
    public final void rule__DMLStatement__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2731:1: ( ( ruleSelectStatement ) | ( ruleInsertStatement ) | ( ruleUpdateStatement ) | ( ruleDeleteStatement ) )
            int alt30=4;
            switch ( input.LA(1) ) {
            case 88:
                {
                alt30=1;
                }
                break;
            case 44:
            case 113:
                {
                alt30=2;
                }
                break;
            case 116:
                {
                alt30=3;
                }
                break;
            case 111:
                {
                alt30=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }

            switch (alt30) {
                case 1 :
                    // InternalMickeyLang.g:2732:2: ( ruleSelectStatement )
                    {
                    // InternalMickeyLang.g:2732:2: ( ruleSelectStatement )
                    // InternalMickeyLang.g:2733:3: ruleSelectStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDMLStatementAccess().getSelectStatementParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleSelectStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDMLStatementAccess().getSelectStatementParserRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2738:2: ( ruleInsertStatement )
                    {
                    // InternalMickeyLang.g:2738:2: ( ruleInsertStatement )
                    // InternalMickeyLang.g:2739:3: ruleInsertStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDMLStatementAccess().getInsertStatementParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleInsertStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDMLStatementAccess().getInsertStatementParserRuleCall_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2744:2: ( ruleUpdateStatement )
                    {
                    // InternalMickeyLang.g:2744:2: ( ruleUpdateStatement )
                    // InternalMickeyLang.g:2745:3: ruleUpdateStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDMLStatementAccess().getUpdateStatementParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleUpdateStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDMLStatementAccess().getUpdateStatementParserRuleCall_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2750:2: ( ruleDeleteStatement )
                    {
                    // InternalMickeyLang.g:2750:2: ( ruleDeleteStatement )
                    // InternalMickeyLang.g:2751:3: ruleDeleteStatement
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDMLStatementAccess().getDeleteStatementParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleDeleteStatement();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDMLStatementAccess().getDeleteStatementParserRuleCall_3()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DMLStatement__Alternatives"


    // $ANTLR start "rule__InsertStatement__Alternatives_0"
    // InternalMickeyLang.g:2760:1: rule__InsertStatement__Alternatives_0 : ( ( ( rule__InsertStatement__Group_0_0__0 ) ) | ( 'replace' ) );
    public final void rule__InsertStatement__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2764:1: ( ( ( rule__InsertStatement__Group_0_0__0 ) ) | ( 'replace' ) )
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0==113) ) {
                alt31=1;
            }
            else if ( (LA31_0==44) ) {
                alt31=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;
            }
            switch (alt31) {
                case 1 :
                    // InternalMickeyLang.g:2765:2: ( ( rule__InsertStatement__Group_0_0__0 ) )
                    {
                    // InternalMickeyLang.g:2765:2: ( ( rule__InsertStatement__Group_0_0__0 ) )
                    // InternalMickeyLang.g:2766:3: ( rule__InsertStatement__Group_0_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getInsertStatementAccess().getGroup_0_0()); 
                    }
                    // InternalMickeyLang.g:2767:3: ( rule__InsertStatement__Group_0_0__0 )
                    // InternalMickeyLang.g:2767:4: rule__InsertStatement__Group_0_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__Group_0_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getInsertStatementAccess().getGroup_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2771:2: ( 'replace' )
                    {
                    // InternalMickeyLang.g:2771:2: ( 'replace' )
                    // InternalMickeyLang.g:2772:3: 'replace'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getInsertStatementAccess().getReplaceKeyword_0_1()); 
                    }
                    match(input,44,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getInsertStatementAccess().getReplaceKeyword_0_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Alternatives_0"


    // $ANTLR start "rule__InsertStatement__Alternatives_4"
    // InternalMickeyLang.g:2781:1: rule__InsertStatement__Alternatives_4 : ( ( ( rule__InsertStatement__Alternatives_4_0 ) ) | ( ( rule__InsertStatement__Group_4_1__0 ) ) );
    public final void rule__InsertStatement__Alternatives_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2785:1: ( ( ( rule__InsertStatement__Alternatives_4_0 ) ) | ( ( rule__InsertStatement__Group_4_1__0 ) ) )
            int alt32=2;
            int LA32_0 = input.LA(1);

            if ( (LA32_0==88||LA32_0==115) ) {
                alt32=1;
            }
            else if ( (LA32_0==106) ) {
                alt32=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 32, 0, input);

                throw nvae;
            }
            switch (alt32) {
                case 1 :
                    // InternalMickeyLang.g:2786:2: ( ( rule__InsertStatement__Alternatives_4_0 ) )
                    {
                    // InternalMickeyLang.g:2786:2: ( ( rule__InsertStatement__Alternatives_4_0 ) )
                    // InternalMickeyLang.g:2787:3: ( rule__InsertStatement__Alternatives_4_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getInsertStatementAccess().getAlternatives_4_0()); 
                    }
                    // InternalMickeyLang.g:2788:3: ( rule__InsertStatement__Alternatives_4_0 )
                    // InternalMickeyLang.g:2788:4: rule__InsertStatement__Alternatives_4_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__Alternatives_4_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getInsertStatementAccess().getAlternatives_4_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2792:2: ( ( rule__InsertStatement__Group_4_1__0 ) )
                    {
                    // InternalMickeyLang.g:2792:2: ( ( rule__InsertStatement__Group_4_1__0 ) )
                    // InternalMickeyLang.g:2793:3: ( rule__InsertStatement__Group_4_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getInsertStatementAccess().getGroup_4_1()); 
                    }
                    // InternalMickeyLang.g:2794:3: ( rule__InsertStatement__Group_4_1__0 )
                    // InternalMickeyLang.g:2794:4: rule__InsertStatement__Group_4_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__Group_4_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getInsertStatementAccess().getGroup_4_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Alternatives_4"


    // $ANTLR start "rule__InsertStatement__Alternatives_4_0"
    // InternalMickeyLang.g:2802:1: rule__InsertStatement__Alternatives_4_0 : ( ( ( rule__InsertStatement__Group_4_0_0__0 ) ) | ( ( rule__InsertStatement__SelectStatementAssignment_4_0_1 ) ) );
    public final void rule__InsertStatement__Alternatives_4_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2806:1: ( ( ( rule__InsertStatement__Group_4_0_0__0 ) ) | ( ( rule__InsertStatement__SelectStatementAssignment_4_0_1 ) ) )
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==115) ) {
                alt33=1;
            }
            else if ( (LA33_0==88) ) {
                alt33=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 33, 0, input);

                throw nvae;
            }
            switch (alt33) {
                case 1 :
                    // InternalMickeyLang.g:2807:2: ( ( rule__InsertStatement__Group_4_0_0__0 ) )
                    {
                    // InternalMickeyLang.g:2807:2: ( ( rule__InsertStatement__Group_4_0_0__0 ) )
                    // InternalMickeyLang.g:2808:3: ( rule__InsertStatement__Group_4_0_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getInsertStatementAccess().getGroup_4_0_0()); 
                    }
                    // InternalMickeyLang.g:2809:3: ( rule__InsertStatement__Group_4_0_0__0 )
                    // InternalMickeyLang.g:2809:4: rule__InsertStatement__Group_4_0_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__Group_4_0_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getInsertStatementAccess().getGroup_4_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2813:2: ( ( rule__InsertStatement__SelectStatementAssignment_4_0_1 ) )
                    {
                    // InternalMickeyLang.g:2813:2: ( ( rule__InsertStatement__SelectStatementAssignment_4_0_1 ) )
                    // InternalMickeyLang.g:2814:3: ( rule__InsertStatement__SelectStatementAssignment_4_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getInsertStatementAccess().getSelectStatementAssignment_4_0_1()); 
                    }
                    // InternalMickeyLang.g:2815:3: ( rule__InsertStatement__SelectStatementAssignment_4_0_1 )
                    // InternalMickeyLang.g:2815:4: rule__InsertStatement__SelectStatementAssignment_4_0_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__SelectStatementAssignment_4_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getInsertStatementAccess().getSelectStatementAssignment_4_0_1()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Alternatives_4_0"


    // $ANTLR start "rule__CompoundOperator__Alternatives"
    // InternalMickeyLang.g:2823:1: rule__CompoundOperator__Alternatives : ( ( ( 'union all' ) ) | ( ( 'union' ) ) | ( ( 'intersect' ) ) | ( ( 'except' ) ) );
    public final void rule__CompoundOperator__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2827:1: ( ( ( 'union all' ) ) | ( ( 'union' ) ) | ( ( 'intersect' ) ) | ( ( 'except' ) ) )
            int alt34=4;
            switch ( input.LA(1) ) {
            case 45:
                {
                alt34=1;
                }
                break;
            case 46:
                {
                alt34=2;
                }
                break;
            case 47:
                {
                alt34=3;
                }
                break;
            case 48:
                {
                alt34=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 34, 0, input);

                throw nvae;
            }

            switch (alt34) {
                case 1 :
                    // InternalMickeyLang.g:2828:2: ( ( 'union all' ) )
                    {
                    // InternalMickeyLang.g:2828:2: ( ( 'union all' ) )
                    // InternalMickeyLang.g:2829:3: ( 'union all' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCompoundOperatorAccess().getUnionallEnumLiteralDeclaration_0()); 
                    }
                    // InternalMickeyLang.g:2830:3: ( 'union all' )
                    // InternalMickeyLang.g:2830:4: 'union all'
                    {
                    match(input,45,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCompoundOperatorAccess().getUnionallEnumLiteralDeclaration_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2834:2: ( ( 'union' ) )
                    {
                    // InternalMickeyLang.g:2834:2: ( ( 'union' ) )
                    // InternalMickeyLang.g:2835:3: ( 'union' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCompoundOperatorAccess().getUnionEnumLiteralDeclaration_1()); 
                    }
                    // InternalMickeyLang.g:2836:3: ( 'union' )
                    // InternalMickeyLang.g:2836:4: 'union'
                    {
                    match(input,46,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCompoundOperatorAccess().getUnionEnumLiteralDeclaration_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2840:2: ( ( 'intersect' ) )
                    {
                    // InternalMickeyLang.g:2840:2: ( ( 'intersect' ) )
                    // InternalMickeyLang.g:2841:3: ( 'intersect' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCompoundOperatorAccess().getIntersectEnumLiteralDeclaration_2()); 
                    }
                    // InternalMickeyLang.g:2842:3: ( 'intersect' )
                    // InternalMickeyLang.g:2842:4: 'intersect'
                    {
                    match(input,47,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCompoundOperatorAccess().getIntersectEnumLiteralDeclaration_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2846:2: ( ( 'except' ) )
                    {
                    // InternalMickeyLang.g:2846:2: ( ( 'except' ) )
                    // InternalMickeyLang.g:2847:3: ( 'except' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCompoundOperatorAccess().getExceptEnumLiteralDeclaration_3()); 
                    }
                    // InternalMickeyLang.g:2848:3: ( 'except' )
                    // InternalMickeyLang.g:2848:4: 'except'
                    {
                    match(input,48,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCompoundOperatorAccess().getExceptEnumLiteralDeclaration_3()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundOperator__Alternatives"


    // $ANTLR start "rule__SqliteDataType__Alternatives"
    // InternalMickeyLang.g:2856:1: rule__SqliteDataType__Alternatives : ( ( ( 'text' ) ) | ( ( 'integer' ) ) | ( ( 'real' ) ) | ( ( 'blob' ) ) | ( ( 'none' ) ) | ( ( 'numeric' ) ) );
    public final void rule__SqliteDataType__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2860:1: ( ( ( 'text' ) ) | ( ( 'integer' ) ) | ( ( 'real' ) ) | ( ( 'blob' ) ) | ( ( 'none' ) ) | ( ( 'numeric' ) ) )
            int alt35=6;
            switch ( input.LA(1) ) {
            case 49:
                {
                alt35=1;
                }
                break;
            case 50:
                {
                alt35=2;
                }
                break;
            case 51:
                {
                alt35=3;
                }
                break;
            case 52:
                {
                alt35=4;
                }
                break;
            case 53:
                {
                alt35=5;
                }
                break;
            case 54:
                {
                alt35=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 35, 0, input);

                throw nvae;
            }

            switch (alt35) {
                case 1 :
                    // InternalMickeyLang.g:2861:2: ( ( 'text' ) )
                    {
                    // InternalMickeyLang.g:2861:2: ( ( 'text' ) )
                    // InternalMickeyLang.g:2862:3: ( 'text' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSqliteDataTypeAccess().getTextEnumLiteralDeclaration_0()); 
                    }
                    // InternalMickeyLang.g:2863:3: ( 'text' )
                    // InternalMickeyLang.g:2863:4: 'text'
                    {
                    match(input,49,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSqliteDataTypeAccess().getTextEnumLiteralDeclaration_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2867:2: ( ( 'integer' ) )
                    {
                    // InternalMickeyLang.g:2867:2: ( ( 'integer' ) )
                    // InternalMickeyLang.g:2868:3: ( 'integer' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSqliteDataTypeAccess().getIntegerEnumLiteralDeclaration_1()); 
                    }
                    // InternalMickeyLang.g:2869:3: ( 'integer' )
                    // InternalMickeyLang.g:2869:4: 'integer'
                    {
                    match(input,50,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSqliteDataTypeAccess().getIntegerEnumLiteralDeclaration_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2873:2: ( ( 'real' ) )
                    {
                    // InternalMickeyLang.g:2873:2: ( ( 'real' ) )
                    // InternalMickeyLang.g:2874:3: ( 'real' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSqliteDataTypeAccess().getRealEnumLiteralDeclaration_2()); 
                    }
                    // InternalMickeyLang.g:2875:3: ( 'real' )
                    // InternalMickeyLang.g:2875:4: 'real'
                    {
                    match(input,51,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSqliteDataTypeAccess().getRealEnumLiteralDeclaration_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2879:2: ( ( 'blob' ) )
                    {
                    // InternalMickeyLang.g:2879:2: ( ( 'blob' ) )
                    // InternalMickeyLang.g:2880:3: ( 'blob' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSqliteDataTypeAccess().getBlobEnumLiteralDeclaration_3()); 
                    }
                    // InternalMickeyLang.g:2881:3: ( 'blob' )
                    // InternalMickeyLang.g:2881:4: 'blob'
                    {
                    match(input,52,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSqliteDataTypeAccess().getBlobEnumLiteralDeclaration_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2885:2: ( ( 'none' ) )
                    {
                    // InternalMickeyLang.g:2885:2: ( ( 'none' ) )
                    // InternalMickeyLang.g:2886:3: ( 'none' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSqliteDataTypeAccess().getNoneEnumLiteralDeclaration_4()); 
                    }
                    // InternalMickeyLang.g:2887:3: ( 'none' )
                    // InternalMickeyLang.g:2887:4: 'none'
                    {
                    match(input,53,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSqliteDataTypeAccess().getNoneEnumLiteralDeclaration_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalMickeyLang.g:2891:2: ( ( 'numeric' ) )
                    {
                    // InternalMickeyLang.g:2891:2: ( ( 'numeric' ) )
                    // InternalMickeyLang.g:2892:3: ( 'numeric' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSqliteDataTypeAccess().getNumericEnumLiteralDeclaration_5()); 
                    }
                    // InternalMickeyLang.g:2893:3: ( 'numeric' )
                    // InternalMickeyLang.g:2893:4: 'numeric'
                    {
                    match(input,54,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSqliteDataTypeAccess().getNumericEnumLiteralDeclaration_5()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SqliteDataType__Alternatives"


    // $ANTLR start "rule__ColumnType__Alternatives"
    // InternalMickeyLang.g:2901:1: rule__ColumnType__Alternatives : ( ( ( 'text' ) ) | ( ( 'integer' ) ) | ( ( 'real' ) ) | ( ( 'blob' ) ) | ( ( 'boolean' ) ) );
    public final void rule__ColumnType__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2905:1: ( ( ( 'text' ) ) | ( ( 'integer' ) ) | ( ( 'real' ) ) | ( ( 'blob' ) ) | ( ( 'boolean' ) ) )
            int alt36=5;
            switch ( input.LA(1) ) {
            case 49:
                {
                alt36=1;
                }
                break;
            case 50:
                {
                alt36=2;
                }
                break;
            case 51:
                {
                alt36=3;
                }
                break;
            case 52:
                {
                alt36=4;
                }
                break;
            case 55:
                {
                alt36=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 36, 0, input);

                throw nvae;
            }

            switch (alt36) {
                case 1 :
                    // InternalMickeyLang.g:2906:2: ( ( 'text' ) )
                    {
                    // InternalMickeyLang.g:2906:2: ( ( 'text' ) )
                    // InternalMickeyLang.g:2907:3: ( 'text' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnTypeAccess().getTextEnumLiteralDeclaration_0()); 
                    }
                    // InternalMickeyLang.g:2908:3: ( 'text' )
                    // InternalMickeyLang.g:2908:4: 'text'
                    {
                    match(input,49,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnTypeAccess().getTextEnumLiteralDeclaration_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2912:2: ( ( 'integer' ) )
                    {
                    // InternalMickeyLang.g:2912:2: ( ( 'integer' ) )
                    // InternalMickeyLang.g:2913:3: ( 'integer' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnTypeAccess().getIntegerEnumLiteralDeclaration_1()); 
                    }
                    // InternalMickeyLang.g:2914:3: ( 'integer' )
                    // InternalMickeyLang.g:2914:4: 'integer'
                    {
                    match(input,50,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnTypeAccess().getIntegerEnumLiteralDeclaration_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2918:2: ( ( 'real' ) )
                    {
                    // InternalMickeyLang.g:2918:2: ( ( 'real' ) )
                    // InternalMickeyLang.g:2919:3: ( 'real' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnTypeAccess().getRealEnumLiteralDeclaration_2()); 
                    }
                    // InternalMickeyLang.g:2920:3: ( 'real' )
                    // InternalMickeyLang.g:2920:4: 'real'
                    {
                    match(input,51,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnTypeAccess().getRealEnumLiteralDeclaration_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2924:2: ( ( 'blob' ) )
                    {
                    // InternalMickeyLang.g:2924:2: ( ( 'blob' ) )
                    // InternalMickeyLang.g:2925:3: ( 'blob' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnTypeAccess().getBlobEnumLiteralDeclaration_3()); 
                    }
                    // InternalMickeyLang.g:2926:3: ( 'blob' )
                    // InternalMickeyLang.g:2926:4: 'blob'
                    {
                    match(input,52,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnTypeAccess().getBlobEnumLiteralDeclaration_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2930:2: ( ( 'boolean' ) )
                    {
                    // InternalMickeyLang.g:2930:2: ( ( 'boolean' ) )
                    // InternalMickeyLang.g:2931:3: ( 'boolean' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getColumnTypeAccess().getBooleanEnumLiteralDeclaration_4()); 
                    }
                    // InternalMickeyLang.g:2932:3: ( 'boolean' )
                    // InternalMickeyLang.g:2932:4: 'boolean'
                    {
                    match(input,55,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getColumnTypeAccess().getBooleanEnumLiteralDeclaration_4()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnType__Alternatives"


    // $ANTLR start "rule__ConflictResolution__Alternatives"
    // InternalMickeyLang.g:2940:1: rule__ConflictResolution__Alternatives : ( ( ( 'rollback' ) ) | ( ( 'abort' ) ) | ( ( 'fail' ) ) | ( ( 'ignore' ) ) | ( ( 'replace' ) ) );
    public final void rule__ConflictResolution__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2944:1: ( ( ( 'rollback' ) ) | ( ( 'abort' ) ) | ( ( 'fail' ) ) | ( ( 'ignore' ) ) | ( ( 'replace' ) ) )
            int alt37=5;
            switch ( input.LA(1) ) {
            case 56:
                {
                alt37=1;
                }
                break;
            case 57:
                {
                alt37=2;
                }
                break;
            case 58:
                {
                alt37=3;
                }
                break;
            case 59:
                {
                alt37=4;
                }
                break;
            case 44:
                {
                alt37=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 37, 0, input);

                throw nvae;
            }

            switch (alt37) {
                case 1 :
                    // InternalMickeyLang.g:2945:2: ( ( 'rollback' ) )
                    {
                    // InternalMickeyLang.g:2945:2: ( ( 'rollback' ) )
                    // InternalMickeyLang.g:2946:3: ( 'rollback' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getConflictResolutionAccess().getRollbackEnumLiteralDeclaration_0()); 
                    }
                    // InternalMickeyLang.g:2947:3: ( 'rollback' )
                    // InternalMickeyLang.g:2947:4: 'rollback'
                    {
                    match(input,56,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getConflictResolutionAccess().getRollbackEnumLiteralDeclaration_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMickeyLang.g:2951:2: ( ( 'abort' ) )
                    {
                    // InternalMickeyLang.g:2951:2: ( ( 'abort' ) )
                    // InternalMickeyLang.g:2952:3: ( 'abort' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getConflictResolutionAccess().getAbortEnumLiteralDeclaration_1()); 
                    }
                    // InternalMickeyLang.g:2953:3: ( 'abort' )
                    // InternalMickeyLang.g:2953:4: 'abort'
                    {
                    match(input,57,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getConflictResolutionAccess().getAbortEnumLiteralDeclaration_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalMickeyLang.g:2957:2: ( ( 'fail' ) )
                    {
                    // InternalMickeyLang.g:2957:2: ( ( 'fail' ) )
                    // InternalMickeyLang.g:2958:3: ( 'fail' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getConflictResolutionAccess().getFailEnumLiteralDeclaration_2()); 
                    }
                    // InternalMickeyLang.g:2959:3: ( 'fail' )
                    // InternalMickeyLang.g:2959:4: 'fail'
                    {
                    match(input,58,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getConflictResolutionAccess().getFailEnumLiteralDeclaration_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalMickeyLang.g:2963:2: ( ( 'ignore' ) )
                    {
                    // InternalMickeyLang.g:2963:2: ( ( 'ignore' ) )
                    // InternalMickeyLang.g:2964:3: ( 'ignore' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getConflictResolutionAccess().getIgnoreEnumLiteralDeclaration_3()); 
                    }
                    // InternalMickeyLang.g:2965:3: ( 'ignore' )
                    // InternalMickeyLang.g:2965:4: 'ignore'
                    {
                    match(input,59,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getConflictResolutionAccess().getIgnoreEnumLiteralDeclaration_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalMickeyLang.g:2969:2: ( ( 'replace' ) )
                    {
                    // InternalMickeyLang.g:2969:2: ( ( 'replace' ) )
                    // InternalMickeyLang.g:2970:3: ( 'replace' )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getConflictResolutionAccess().getReplaceEnumLiteralDeclaration_4()); 
                    }
                    // InternalMickeyLang.g:2971:3: ( 'replace' )
                    // InternalMickeyLang.g:2971:4: 'replace'
                    {
                    match(input,44,FOLLOW_2); if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getConflictResolutionAccess().getReplaceEnumLiteralDeclaration_4()); 
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictResolution__Alternatives"


    // $ANTLR start "rule__MickeyFile__Group__0"
    // InternalMickeyLang.g:2979:1: rule__MickeyFile__Group__0 : rule__MickeyFile__Group__0__Impl rule__MickeyFile__Group__1 ;
    public final void rule__MickeyFile__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2983:1: ( rule__MickeyFile__Group__0__Impl rule__MickeyFile__Group__1 )
            // InternalMickeyLang.g:2984:2: rule__MickeyFile__Group__0__Impl rule__MickeyFile__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__MickeyFile__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFile__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__Group__0"


    // $ANTLR start "rule__MickeyFile__Group__0__Impl"
    // InternalMickeyLang.g:2991:1: rule__MickeyFile__Group__0__Impl : ( 'database' ) ;
    public final void rule__MickeyFile__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:2995:1: ( ( 'database' ) )
            // InternalMickeyLang.g:2996:1: ( 'database' )
            {
            // InternalMickeyLang.g:2996:1: ( 'database' )
            // InternalMickeyLang.g:2997:2: 'database'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileAccess().getDatabaseKeyword_0()); 
            }
            match(input,60,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileAccess().getDatabaseKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__Group__0__Impl"


    // $ANTLR start "rule__MickeyFile__Group__1"
    // InternalMickeyLang.g:3006:1: rule__MickeyFile__Group__1 : rule__MickeyFile__Group__1__Impl rule__MickeyFile__Group__2 ;
    public final void rule__MickeyFile__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3010:1: ( rule__MickeyFile__Group__1__Impl rule__MickeyFile__Group__2 )
            // InternalMickeyLang.g:3011:2: rule__MickeyFile__Group__1__Impl rule__MickeyFile__Group__2
            {
            pushFollow(FOLLOW_4);
            rule__MickeyFile__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFile__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__Group__1"


    // $ANTLR start "rule__MickeyFile__Group__1__Impl"
    // InternalMickeyLang.g:3018:1: rule__MickeyFile__Group__1__Impl : ( ( rule__MickeyFile__DatabaseNameAssignment_1 ) ) ;
    public final void rule__MickeyFile__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3022:1: ( ( ( rule__MickeyFile__DatabaseNameAssignment_1 ) ) )
            // InternalMickeyLang.g:3023:1: ( ( rule__MickeyFile__DatabaseNameAssignment_1 ) )
            {
            // InternalMickeyLang.g:3023:1: ( ( rule__MickeyFile__DatabaseNameAssignment_1 ) )
            // InternalMickeyLang.g:3024:2: ( rule__MickeyFile__DatabaseNameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileAccess().getDatabaseNameAssignment_1()); 
            }
            // InternalMickeyLang.g:3025:2: ( rule__MickeyFile__DatabaseNameAssignment_1 )
            // InternalMickeyLang.g:3025:3: rule__MickeyFile__DatabaseNameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFile__DatabaseNameAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileAccess().getDatabaseNameAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__Group__1__Impl"


    // $ANTLR start "rule__MickeyFile__Group__2"
    // InternalMickeyLang.g:3033:1: rule__MickeyFile__Group__2 : rule__MickeyFile__Group__2__Impl ;
    public final void rule__MickeyFile__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3037:1: ( rule__MickeyFile__Group__2__Impl )
            // InternalMickeyLang.g:3038:2: rule__MickeyFile__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFile__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__Group__2"


    // $ANTLR start "rule__MickeyFile__Group__2__Impl"
    // InternalMickeyLang.g:3044:1: rule__MickeyFile__Group__2__Impl : ( ( rule__MickeyFile__BlocksAssignment_2 )* ) ;
    public final void rule__MickeyFile__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3048:1: ( ( ( rule__MickeyFile__BlocksAssignment_2 )* ) )
            // InternalMickeyLang.g:3049:1: ( ( rule__MickeyFile__BlocksAssignment_2 )* )
            {
            // InternalMickeyLang.g:3049:1: ( ( rule__MickeyFile__BlocksAssignment_2 )* )
            // InternalMickeyLang.g:3050:2: ( rule__MickeyFile__BlocksAssignment_2 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileAccess().getBlocksAssignment_2()); 
            }
            // InternalMickeyLang.g:3051:2: ( rule__MickeyFile__BlocksAssignment_2 )*
            loop38:
            do {
                int alt38=2;
                int LA38_0 = input.LA(1);

                if ( (LA38_0==61||LA38_0==68||LA38_0==72||LA38_0==93||LA38_0==99||LA38_0==102) ) {
                    alt38=1;
                }


                switch (alt38) {
            	case 1 :
            	    // InternalMickeyLang.g:3051:3: rule__MickeyFile__BlocksAssignment_2
            	    {
            	    pushFollow(FOLLOW_5);
            	    rule__MickeyFile__BlocksAssignment_2();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop38;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileAccess().getBlocksAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__Group__2__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__0"
    // InternalMickeyLang.g:3060:1: rule__MickeyFunction__Group__0 : rule__MickeyFunction__Group__0__Impl rule__MickeyFunction__Group__1 ;
    public final void rule__MickeyFunction__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3064:1: ( rule__MickeyFunction__Group__0__Impl rule__MickeyFunction__Group__1 )
            // InternalMickeyLang.g:3065:2: rule__MickeyFunction__Group__0__Impl rule__MickeyFunction__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__MickeyFunction__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__0"


    // $ANTLR start "rule__MickeyFunction__Group__0__Impl"
    // InternalMickeyLang.g:3072:1: rule__MickeyFunction__Group__0__Impl : ( 'function' ) ;
    public final void rule__MickeyFunction__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3076:1: ( ( 'function' ) )
            // InternalMickeyLang.g:3077:1: ( 'function' )
            {
            // InternalMickeyLang.g:3077:1: ( 'function' )
            // InternalMickeyLang.g:3078:2: 'function'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getFunctionKeyword_0()); 
            }
            match(input,61,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getFunctionKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__0__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__1"
    // InternalMickeyLang.g:3087:1: rule__MickeyFunction__Group__1 : rule__MickeyFunction__Group__1__Impl rule__MickeyFunction__Group__2 ;
    public final void rule__MickeyFunction__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3091:1: ( rule__MickeyFunction__Group__1__Impl rule__MickeyFunction__Group__2 )
            // InternalMickeyLang.g:3092:2: rule__MickeyFunction__Group__1__Impl rule__MickeyFunction__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__MickeyFunction__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__1"


    // $ANTLR start "rule__MickeyFunction__Group__1__Impl"
    // InternalMickeyLang.g:3099:1: rule__MickeyFunction__Group__1__Impl : ( ( rule__MickeyFunction__NameAssignment_1 ) ) ;
    public final void rule__MickeyFunction__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3103:1: ( ( ( rule__MickeyFunction__NameAssignment_1 ) ) )
            // InternalMickeyLang.g:3104:1: ( ( rule__MickeyFunction__NameAssignment_1 ) )
            {
            // InternalMickeyLang.g:3104:1: ( ( rule__MickeyFunction__NameAssignment_1 ) )
            // InternalMickeyLang.g:3105:2: ( rule__MickeyFunction__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getNameAssignment_1()); 
            }
            // InternalMickeyLang.g:3106:2: ( rule__MickeyFunction__NameAssignment_1 )
            // InternalMickeyLang.g:3106:3: rule__MickeyFunction__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__NameAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getNameAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__1__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__2"
    // InternalMickeyLang.g:3114:1: rule__MickeyFunction__Group__2 : rule__MickeyFunction__Group__2__Impl rule__MickeyFunction__Group__3 ;
    public final void rule__MickeyFunction__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3118:1: ( rule__MickeyFunction__Group__2__Impl rule__MickeyFunction__Group__3 )
            // InternalMickeyLang.g:3119:2: rule__MickeyFunction__Group__2__Impl rule__MickeyFunction__Group__3
            {
            pushFollow(FOLLOW_7);
            rule__MickeyFunction__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__2"


    // $ANTLR start "rule__MickeyFunction__Group__2__Impl"
    // InternalMickeyLang.g:3126:1: rule__MickeyFunction__Group__2__Impl : ( '(' ) ;
    public final void rule__MickeyFunction__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3130:1: ( ( '(' ) )
            // InternalMickeyLang.g:3131:1: ( '(' )
            {
            // InternalMickeyLang.g:3131:1: ( '(' )
            // InternalMickeyLang.g:3132:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getLeftParenthesisKeyword_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getLeftParenthesisKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__2__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__3"
    // InternalMickeyLang.g:3141:1: rule__MickeyFunction__Group__3 : rule__MickeyFunction__Group__3__Impl rule__MickeyFunction__Group__4 ;
    public final void rule__MickeyFunction__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3145:1: ( rule__MickeyFunction__Group__3__Impl rule__MickeyFunction__Group__4 )
            // InternalMickeyLang.g:3146:2: rule__MickeyFunction__Group__3__Impl rule__MickeyFunction__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__MickeyFunction__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__3"


    // $ANTLR start "rule__MickeyFunction__Group__3__Impl"
    // InternalMickeyLang.g:3153:1: rule__MickeyFunction__Group__3__Impl : ( ( rule__MickeyFunction__Group_3__0 )? ) ;
    public final void rule__MickeyFunction__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3157:1: ( ( ( rule__MickeyFunction__Group_3__0 )? ) )
            // InternalMickeyLang.g:3158:1: ( ( rule__MickeyFunction__Group_3__0 )? )
            {
            // InternalMickeyLang.g:3158:1: ( ( rule__MickeyFunction__Group_3__0 )? )
            // InternalMickeyLang.g:3159:2: ( rule__MickeyFunction__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getGroup_3()); 
            }
            // InternalMickeyLang.g:3160:2: ( rule__MickeyFunction__Group_3__0 )?
            int alt39=2;
            int LA39_0 = input.LA(1);

            if ( ((LA39_0>=49 && LA39_0<=52)||LA39_0==55) ) {
                alt39=1;
            }
            switch (alt39) {
                case 1 :
                    // InternalMickeyLang.g:3160:3: rule__MickeyFunction__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__MickeyFunction__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getGroup_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__3__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__4"
    // InternalMickeyLang.g:3168:1: rule__MickeyFunction__Group__4 : rule__MickeyFunction__Group__4__Impl rule__MickeyFunction__Group__5 ;
    public final void rule__MickeyFunction__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3172:1: ( rule__MickeyFunction__Group__4__Impl rule__MickeyFunction__Group__5 )
            // InternalMickeyLang.g:3173:2: rule__MickeyFunction__Group__4__Impl rule__MickeyFunction__Group__5
            {
            pushFollow(FOLLOW_8);
            rule__MickeyFunction__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__4"


    // $ANTLR start "rule__MickeyFunction__Group__4__Impl"
    // InternalMickeyLang.g:3180:1: rule__MickeyFunction__Group__4__Impl : ( ')' ) ;
    public final void rule__MickeyFunction__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3184:1: ( ( ')' ) )
            // InternalMickeyLang.g:3185:1: ( ')' )
            {
            // InternalMickeyLang.g:3185:1: ( ')' )
            // InternalMickeyLang.g:3186:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getRightParenthesisKeyword_4()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getRightParenthesisKeyword_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__4__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__5"
    // InternalMickeyLang.g:3195:1: rule__MickeyFunction__Group__5 : rule__MickeyFunction__Group__5__Impl rule__MickeyFunction__Group__6 ;
    public final void rule__MickeyFunction__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3199:1: ( rule__MickeyFunction__Group__5__Impl rule__MickeyFunction__Group__6 )
            // InternalMickeyLang.g:3200:2: rule__MickeyFunction__Group__5__Impl rule__MickeyFunction__Group__6
            {
            pushFollow(FOLLOW_8);
            rule__MickeyFunction__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__5"


    // $ANTLR start "rule__MickeyFunction__Group__5__Impl"
    // InternalMickeyLang.g:3207:1: rule__MickeyFunction__Group__5__Impl : ( ( rule__MickeyFunction__Group_5__0 )? ) ;
    public final void rule__MickeyFunction__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3211:1: ( ( ( rule__MickeyFunction__Group_5__0 )? ) )
            // InternalMickeyLang.g:3212:1: ( ( rule__MickeyFunction__Group_5__0 )? )
            {
            // InternalMickeyLang.g:3212:1: ( ( rule__MickeyFunction__Group_5__0 )? )
            // InternalMickeyLang.g:3213:2: ( rule__MickeyFunction__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getGroup_5()); 
            }
            // InternalMickeyLang.g:3214:2: ( rule__MickeyFunction__Group_5__0 )?
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( (LA40_0==66) ) {
                alt40=1;
            }
            switch (alt40) {
                case 1 :
                    // InternalMickeyLang.g:3214:3: rule__MickeyFunction__Group_5__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__MickeyFunction__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getGroup_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__5__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__6"
    // InternalMickeyLang.g:3222:1: rule__MickeyFunction__Group__6 : rule__MickeyFunction__Group__6__Impl rule__MickeyFunction__Group__7 ;
    public final void rule__MickeyFunction__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3226:1: ( rule__MickeyFunction__Group__6__Impl rule__MickeyFunction__Group__7 )
            // InternalMickeyLang.g:3227:2: rule__MickeyFunction__Group__6__Impl rule__MickeyFunction__Group__7
            {
            pushFollow(FOLLOW_9);
            rule__MickeyFunction__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__6"


    // $ANTLR start "rule__MickeyFunction__Group__6__Impl"
    // InternalMickeyLang.g:3234:1: rule__MickeyFunction__Group__6__Impl : ( '{' ) ;
    public final void rule__MickeyFunction__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3238:1: ( ( '{' ) )
            // InternalMickeyLang.g:3239:1: ( '{' )
            {
            // InternalMickeyLang.g:3239:1: ( '{' )
            // InternalMickeyLang.g:3240:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getLeftCurlyBracketKeyword_6()); 
            }
            match(input,64,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getLeftCurlyBracketKeyword_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__6__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__7"
    // InternalMickeyLang.g:3249:1: rule__MickeyFunction__Group__7 : rule__MickeyFunction__Group__7__Impl rule__MickeyFunction__Group__8 ;
    public final void rule__MickeyFunction__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3253:1: ( rule__MickeyFunction__Group__7__Impl rule__MickeyFunction__Group__8 )
            // InternalMickeyLang.g:3254:2: rule__MickeyFunction__Group__7__Impl rule__MickeyFunction__Group__8
            {
            pushFollow(FOLLOW_9);
            rule__MickeyFunction__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__8();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__7"


    // $ANTLR start "rule__MickeyFunction__Group__7__Impl"
    // InternalMickeyLang.g:3261:1: rule__MickeyFunction__Group__7__Impl : ( ( rule__MickeyFunction__Group_7__0 )* ) ;
    public final void rule__MickeyFunction__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3265:1: ( ( ( rule__MickeyFunction__Group_7__0 )* ) )
            // InternalMickeyLang.g:3266:1: ( ( rule__MickeyFunction__Group_7__0 )* )
            {
            // InternalMickeyLang.g:3266:1: ( ( rule__MickeyFunction__Group_7__0 )* )
            // InternalMickeyLang.g:3267:2: ( rule__MickeyFunction__Group_7__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getGroup_7()); 
            }
            // InternalMickeyLang.g:3268:2: ( rule__MickeyFunction__Group_7__0 )*
            loop41:
            do {
                int alt41=2;
                int LA41_0 = input.LA(1);

                if ( (LA41_0==44||LA41_0==88||LA41_0==111||LA41_0==113||LA41_0==116) ) {
                    alt41=1;
                }


                switch (alt41) {
            	case 1 :
            	    // InternalMickeyLang.g:3268:3: rule__MickeyFunction__Group_7__0
            	    {
            	    pushFollow(FOLLOW_10);
            	    rule__MickeyFunction__Group_7__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop41;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getGroup_7()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__7__Impl"


    // $ANTLR start "rule__MickeyFunction__Group__8"
    // InternalMickeyLang.g:3276:1: rule__MickeyFunction__Group__8 : rule__MickeyFunction__Group__8__Impl ;
    public final void rule__MickeyFunction__Group__8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3280:1: ( rule__MickeyFunction__Group__8__Impl )
            // InternalMickeyLang.g:3281:2: rule__MickeyFunction__Group__8__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group__8__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__8"


    // $ANTLR start "rule__MickeyFunction__Group__8__Impl"
    // InternalMickeyLang.g:3287:1: rule__MickeyFunction__Group__8__Impl : ( '}' ) ;
    public final void rule__MickeyFunction__Group__8__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3291:1: ( ( '}' ) )
            // InternalMickeyLang.g:3292:1: ( '}' )
            {
            // InternalMickeyLang.g:3292:1: ( '}' )
            // InternalMickeyLang.g:3293:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getRightCurlyBracketKeyword_8()); 
            }
            match(input,65,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getRightCurlyBracketKeyword_8()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group__8__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_3__0"
    // InternalMickeyLang.g:3303:1: rule__MickeyFunction__Group_3__0 : rule__MickeyFunction__Group_3__0__Impl rule__MickeyFunction__Group_3__1 ;
    public final void rule__MickeyFunction__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3307:1: ( rule__MickeyFunction__Group_3__0__Impl rule__MickeyFunction__Group_3__1 )
            // InternalMickeyLang.g:3308:2: rule__MickeyFunction__Group_3__0__Impl rule__MickeyFunction__Group_3__1
            {
            pushFollow(FOLLOW_11);
            rule__MickeyFunction__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3__0"


    // $ANTLR start "rule__MickeyFunction__Group_3__0__Impl"
    // InternalMickeyLang.g:3315:1: rule__MickeyFunction__Group_3__0__Impl : ( ( rule__MickeyFunction__ArgsAssignment_3_0 ) ) ;
    public final void rule__MickeyFunction__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3319:1: ( ( ( rule__MickeyFunction__ArgsAssignment_3_0 ) ) )
            // InternalMickeyLang.g:3320:1: ( ( rule__MickeyFunction__ArgsAssignment_3_0 ) )
            {
            // InternalMickeyLang.g:3320:1: ( ( rule__MickeyFunction__ArgsAssignment_3_0 ) )
            // InternalMickeyLang.g:3321:2: ( rule__MickeyFunction__ArgsAssignment_3_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getArgsAssignment_3_0()); 
            }
            // InternalMickeyLang.g:3322:2: ( rule__MickeyFunction__ArgsAssignment_3_0 )
            // InternalMickeyLang.g:3322:3: rule__MickeyFunction__ArgsAssignment_3_0
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__ArgsAssignment_3_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getArgsAssignment_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3__0__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_3__1"
    // InternalMickeyLang.g:3330:1: rule__MickeyFunction__Group_3__1 : rule__MickeyFunction__Group_3__1__Impl ;
    public final void rule__MickeyFunction__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3334:1: ( rule__MickeyFunction__Group_3__1__Impl )
            // InternalMickeyLang.g:3335:2: rule__MickeyFunction__Group_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3__1"


    // $ANTLR start "rule__MickeyFunction__Group_3__1__Impl"
    // InternalMickeyLang.g:3341:1: rule__MickeyFunction__Group_3__1__Impl : ( ( rule__MickeyFunction__Group_3_1__0 )* ) ;
    public final void rule__MickeyFunction__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3345:1: ( ( ( rule__MickeyFunction__Group_3_1__0 )* ) )
            // InternalMickeyLang.g:3346:1: ( ( rule__MickeyFunction__Group_3_1__0 )* )
            {
            // InternalMickeyLang.g:3346:1: ( ( rule__MickeyFunction__Group_3_1__0 )* )
            // InternalMickeyLang.g:3347:2: ( rule__MickeyFunction__Group_3_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getGroup_3_1()); 
            }
            // InternalMickeyLang.g:3348:2: ( rule__MickeyFunction__Group_3_1__0 )*
            loop42:
            do {
                int alt42=2;
                int LA42_0 = input.LA(1);

                if ( (LA42_0==40) ) {
                    alt42=1;
                }


                switch (alt42) {
            	case 1 :
            	    // InternalMickeyLang.g:3348:3: rule__MickeyFunction__Group_3_1__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__MickeyFunction__Group_3_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop42;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getGroup_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3__1__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_3_1__0"
    // InternalMickeyLang.g:3357:1: rule__MickeyFunction__Group_3_1__0 : rule__MickeyFunction__Group_3_1__0__Impl rule__MickeyFunction__Group_3_1__1 ;
    public final void rule__MickeyFunction__Group_3_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3361:1: ( rule__MickeyFunction__Group_3_1__0__Impl rule__MickeyFunction__Group_3_1__1 )
            // InternalMickeyLang.g:3362:2: rule__MickeyFunction__Group_3_1__0__Impl rule__MickeyFunction__Group_3_1__1
            {
            pushFollow(FOLLOW_13);
            rule__MickeyFunction__Group_3_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_3_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3_1__0"


    // $ANTLR start "rule__MickeyFunction__Group_3_1__0__Impl"
    // InternalMickeyLang.g:3369:1: rule__MickeyFunction__Group_3_1__0__Impl : ( ',' ) ;
    public final void rule__MickeyFunction__Group_3_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3373:1: ( ( ',' ) )
            // InternalMickeyLang.g:3374:1: ( ',' )
            {
            // InternalMickeyLang.g:3374:1: ( ',' )
            // InternalMickeyLang.g:3375:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getCommaKeyword_3_1_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getCommaKeyword_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3_1__0__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_3_1__1"
    // InternalMickeyLang.g:3384:1: rule__MickeyFunction__Group_3_1__1 : rule__MickeyFunction__Group_3_1__1__Impl ;
    public final void rule__MickeyFunction__Group_3_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3388:1: ( rule__MickeyFunction__Group_3_1__1__Impl )
            // InternalMickeyLang.g:3389:2: rule__MickeyFunction__Group_3_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_3_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3_1__1"


    // $ANTLR start "rule__MickeyFunction__Group_3_1__1__Impl"
    // InternalMickeyLang.g:3395:1: rule__MickeyFunction__Group_3_1__1__Impl : ( ( rule__MickeyFunction__ArgsAssignment_3_1_1 ) ) ;
    public final void rule__MickeyFunction__Group_3_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3399:1: ( ( ( rule__MickeyFunction__ArgsAssignment_3_1_1 ) ) )
            // InternalMickeyLang.g:3400:1: ( ( rule__MickeyFunction__ArgsAssignment_3_1_1 ) )
            {
            // InternalMickeyLang.g:3400:1: ( ( rule__MickeyFunction__ArgsAssignment_3_1_1 ) )
            // InternalMickeyLang.g:3401:2: ( rule__MickeyFunction__ArgsAssignment_3_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getArgsAssignment_3_1_1()); 
            }
            // InternalMickeyLang.g:3402:2: ( rule__MickeyFunction__ArgsAssignment_3_1_1 )
            // InternalMickeyLang.g:3402:3: rule__MickeyFunction__ArgsAssignment_3_1_1
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__ArgsAssignment_3_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getArgsAssignment_3_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_3_1__1__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_5__0"
    // InternalMickeyLang.g:3411:1: rule__MickeyFunction__Group_5__0 : rule__MickeyFunction__Group_5__0__Impl rule__MickeyFunction__Group_5__1 ;
    public final void rule__MickeyFunction__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3415:1: ( rule__MickeyFunction__Group_5__0__Impl rule__MickeyFunction__Group_5__1 )
            // InternalMickeyLang.g:3416:2: rule__MickeyFunction__Group_5__0__Impl rule__MickeyFunction__Group_5__1
            {
            pushFollow(FOLLOW_3);
            rule__MickeyFunction__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_5__0"


    // $ANTLR start "rule__MickeyFunction__Group_5__0__Impl"
    // InternalMickeyLang.g:3423:1: rule__MickeyFunction__Group_5__0__Impl : ( ':' ) ;
    public final void rule__MickeyFunction__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3427:1: ( ( ':' ) )
            // InternalMickeyLang.g:3428:1: ( ':' )
            {
            // InternalMickeyLang.g:3428:1: ( ':' )
            // InternalMickeyLang.g:3429:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getColonKeyword_5_0()); 
            }
            match(input,66,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getColonKeyword_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_5__0__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_5__1"
    // InternalMickeyLang.g:3438:1: rule__MickeyFunction__Group_5__1 : rule__MickeyFunction__Group_5__1__Impl ;
    public final void rule__MickeyFunction__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3442:1: ( rule__MickeyFunction__Group_5__1__Impl )
            // InternalMickeyLang.g:3443:2: rule__MickeyFunction__Group_5__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_5__1"


    // $ANTLR start "rule__MickeyFunction__Group_5__1__Impl"
    // InternalMickeyLang.g:3449:1: rule__MickeyFunction__Group_5__1__Impl : ( ( rule__MickeyFunction__TypeAssignment_5_1 ) ) ;
    public final void rule__MickeyFunction__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3453:1: ( ( ( rule__MickeyFunction__TypeAssignment_5_1 ) ) )
            // InternalMickeyLang.g:3454:1: ( ( rule__MickeyFunction__TypeAssignment_5_1 ) )
            {
            // InternalMickeyLang.g:3454:1: ( ( rule__MickeyFunction__TypeAssignment_5_1 ) )
            // InternalMickeyLang.g:3455:2: ( rule__MickeyFunction__TypeAssignment_5_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getTypeAssignment_5_1()); 
            }
            // InternalMickeyLang.g:3456:2: ( rule__MickeyFunction__TypeAssignment_5_1 )
            // InternalMickeyLang.g:3456:3: rule__MickeyFunction__TypeAssignment_5_1
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__TypeAssignment_5_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getTypeAssignment_5_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_5__1__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_7__0"
    // InternalMickeyLang.g:3465:1: rule__MickeyFunction__Group_7__0 : rule__MickeyFunction__Group_7__0__Impl rule__MickeyFunction__Group_7__1 ;
    public final void rule__MickeyFunction__Group_7__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3469:1: ( rule__MickeyFunction__Group_7__0__Impl rule__MickeyFunction__Group_7__1 )
            // InternalMickeyLang.g:3470:2: rule__MickeyFunction__Group_7__0__Impl rule__MickeyFunction__Group_7__1
            {
            pushFollow(FOLLOW_14);
            rule__MickeyFunction__Group_7__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_7__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_7__0"


    // $ANTLR start "rule__MickeyFunction__Group_7__0__Impl"
    // InternalMickeyLang.g:3477:1: rule__MickeyFunction__Group_7__0__Impl : ( ( rule__MickeyFunction__StatementsAssignment_7_0 ) ) ;
    public final void rule__MickeyFunction__Group_7__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3481:1: ( ( ( rule__MickeyFunction__StatementsAssignment_7_0 ) ) )
            // InternalMickeyLang.g:3482:1: ( ( rule__MickeyFunction__StatementsAssignment_7_0 ) )
            {
            // InternalMickeyLang.g:3482:1: ( ( rule__MickeyFunction__StatementsAssignment_7_0 ) )
            // InternalMickeyLang.g:3483:2: ( rule__MickeyFunction__StatementsAssignment_7_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getStatementsAssignment_7_0()); 
            }
            // InternalMickeyLang.g:3484:2: ( rule__MickeyFunction__StatementsAssignment_7_0 )
            // InternalMickeyLang.g:3484:3: rule__MickeyFunction__StatementsAssignment_7_0
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__StatementsAssignment_7_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getStatementsAssignment_7_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_7__0__Impl"


    // $ANTLR start "rule__MickeyFunction__Group_7__1"
    // InternalMickeyLang.g:3492:1: rule__MickeyFunction__Group_7__1 : rule__MickeyFunction__Group_7__1__Impl ;
    public final void rule__MickeyFunction__Group_7__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3496:1: ( rule__MickeyFunction__Group_7__1__Impl )
            // InternalMickeyLang.g:3497:2: rule__MickeyFunction__Group_7__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MickeyFunction__Group_7__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_7__1"


    // $ANTLR start "rule__MickeyFunction__Group_7__1__Impl"
    // InternalMickeyLang.g:3503:1: rule__MickeyFunction__Group_7__1__Impl : ( ';' ) ;
    public final void rule__MickeyFunction__Group_7__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3507:1: ( ( ';' ) )
            // InternalMickeyLang.g:3508:1: ( ';' )
            {
            // InternalMickeyLang.g:3508:1: ( ';' )
            // InternalMickeyLang.g:3509:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getSemicolonKeyword_7_1()); 
            }
            match(input,67,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getSemicolonKeyword_7_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__Group_7__1__Impl"


    // $ANTLR start "rule__ActionStatement__Group__0"
    // InternalMickeyLang.g:3519:1: rule__ActionStatement__Group__0 : rule__ActionStatement__Group__0__Impl rule__ActionStatement__Group__1 ;
    public final void rule__ActionStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3523:1: ( rule__ActionStatement__Group__0__Impl rule__ActionStatement__Group__1 )
            // InternalMickeyLang.g:3524:2: rule__ActionStatement__Group__0__Impl rule__ActionStatement__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__ActionStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__0"


    // $ANTLR start "rule__ActionStatement__Group__0__Impl"
    // InternalMickeyLang.g:3531:1: rule__ActionStatement__Group__0__Impl : ( 'action' ) ;
    public final void rule__ActionStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3535:1: ( ( 'action' ) )
            // InternalMickeyLang.g:3536:1: ( 'action' )
            {
            // InternalMickeyLang.g:3536:1: ( 'action' )
            // InternalMickeyLang.g:3537:2: 'action'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getActionKeyword_0()); 
            }
            match(input,68,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getActionKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__0__Impl"


    // $ANTLR start "rule__ActionStatement__Group__1"
    // InternalMickeyLang.g:3546:1: rule__ActionStatement__Group__1 : rule__ActionStatement__Group__1__Impl rule__ActionStatement__Group__2 ;
    public final void rule__ActionStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3550:1: ( rule__ActionStatement__Group__1__Impl rule__ActionStatement__Group__2 )
            // InternalMickeyLang.g:3551:2: rule__ActionStatement__Group__1__Impl rule__ActionStatement__Group__2
            {
            pushFollow(FOLLOW_15);
            rule__ActionStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__1"


    // $ANTLR start "rule__ActionStatement__Group__1__Impl"
    // InternalMickeyLang.g:3558:1: rule__ActionStatement__Group__1__Impl : ( ( rule__ActionStatement__NameAssignment_1 ) ) ;
    public final void rule__ActionStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3562:1: ( ( ( rule__ActionStatement__NameAssignment_1 ) ) )
            // InternalMickeyLang.g:3563:1: ( ( rule__ActionStatement__NameAssignment_1 ) )
            {
            // InternalMickeyLang.g:3563:1: ( ( rule__ActionStatement__NameAssignment_1 ) )
            // InternalMickeyLang.g:3564:2: ( rule__ActionStatement__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getNameAssignment_1()); 
            }
            // InternalMickeyLang.g:3565:2: ( rule__ActionStatement__NameAssignment_1 )
            // InternalMickeyLang.g:3565:3: rule__ActionStatement__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ActionStatement__NameAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getNameAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__1__Impl"


    // $ANTLR start "rule__ActionStatement__Group__2"
    // InternalMickeyLang.g:3573:1: rule__ActionStatement__Group__2 : rule__ActionStatement__Group__2__Impl rule__ActionStatement__Group__3 ;
    public final void rule__ActionStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3577:1: ( rule__ActionStatement__Group__2__Impl rule__ActionStatement__Group__3 )
            // InternalMickeyLang.g:3578:2: rule__ActionStatement__Group__2__Impl rule__ActionStatement__Group__3
            {
            pushFollow(FOLLOW_16);
            rule__ActionStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__2"


    // $ANTLR start "rule__ActionStatement__Group__2__Impl"
    // InternalMickeyLang.g:3585:1: rule__ActionStatement__Group__2__Impl : ( ( rule__ActionStatement__UriAssignment_2 ) ) ;
    public final void rule__ActionStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3589:1: ( ( ( rule__ActionStatement__UriAssignment_2 ) ) )
            // InternalMickeyLang.g:3590:1: ( ( rule__ActionStatement__UriAssignment_2 ) )
            {
            // InternalMickeyLang.g:3590:1: ( ( rule__ActionStatement__UriAssignment_2 ) )
            // InternalMickeyLang.g:3591:2: ( rule__ActionStatement__UriAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getUriAssignment_2()); 
            }
            // InternalMickeyLang.g:3592:2: ( rule__ActionStatement__UriAssignment_2 )
            // InternalMickeyLang.g:3592:3: rule__ActionStatement__UriAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ActionStatement__UriAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getUriAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__2__Impl"


    // $ANTLR start "rule__ActionStatement__Group__3"
    // InternalMickeyLang.g:3600:1: rule__ActionStatement__Group__3 : rule__ActionStatement__Group__3__Impl rule__ActionStatement__Group__4 ;
    public final void rule__ActionStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3604:1: ( rule__ActionStatement__Group__3__Impl rule__ActionStatement__Group__4 )
            // InternalMickeyLang.g:3605:2: rule__ActionStatement__Group__3__Impl rule__ActionStatement__Group__4
            {
            pushFollow(FOLLOW_3);
            rule__ActionStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__3"


    // $ANTLR start "rule__ActionStatement__Group__3__Impl"
    // InternalMickeyLang.g:3612:1: rule__ActionStatement__Group__3__Impl : ( 'on' ) ;
    public final void rule__ActionStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3616:1: ( ( 'on' ) )
            // InternalMickeyLang.g:3617:1: ( 'on' )
            {
            // InternalMickeyLang.g:3617:1: ( 'on' )
            // InternalMickeyLang.g:3618:2: 'on'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getOnKeyword_3()); 
            }
            match(input,69,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getOnKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__3__Impl"


    // $ANTLR start "rule__ActionStatement__Group__4"
    // InternalMickeyLang.g:3627:1: rule__ActionStatement__Group__4 : rule__ActionStatement__Group__4__Impl rule__ActionStatement__Group__5 ;
    public final void rule__ActionStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3631:1: ( rule__ActionStatement__Group__4__Impl rule__ActionStatement__Group__5 )
            // InternalMickeyLang.g:3632:2: rule__ActionStatement__Group__4__Impl rule__ActionStatement__Group__5
            {
            pushFollow(FOLLOW_17);
            rule__ActionStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__4"


    // $ANTLR start "rule__ActionStatement__Group__4__Impl"
    // InternalMickeyLang.g:3639:1: rule__ActionStatement__Group__4__Impl : ( ( rule__ActionStatement__TypeAssignment_4 ) ) ;
    public final void rule__ActionStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3643:1: ( ( ( rule__ActionStatement__TypeAssignment_4 ) ) )
            // InternalMickeyLang.g:3644:1: ( ( rule__ActionStatement__TypeAssignment_4 ) )
            {
            // InternalMickeyLang.g:3644:1: ( ( rule__ActionStatement__TypeAssignment_4 ) )
            // InternalMickeyLang.g:3645:2: ( rule__ActionStatement__TypeAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getTypeAssignment_4()); 
            }
            // InternalMickeyLang.g:3646:2: ( rule__ActionStatement__TypeAssignment_4 )
            // InternalMickeyLang.g:3646:3: rule__ActionStatement__TypeAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__ActionStatement__TypeAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getTypeAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__4__Impl"


    // $ANTLR start "rule__ActionStatement__Group__5"
    // InternalMickeyLang.g:3654:1: rule__ActionStatement__Group__5 : rule__ActionStatement__Group__5__Impl rule__ActionStatement__Group__6 ;
    public final void rule__ActionStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3658:1: ( rule__ActionStatement__Group__5__Impl rule__ActionStatement__Group__6 )
            // InternalMickeyLang.g:3659:2: rule__ActionStatement__Group__5__Impl rule__ActionStatement__Group__6
            {
            pushFollow(FOLLOW_17);
            rule__ActionStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__5"


    // $ANTLR start "rule__ActionStatement__Group__5__Impl"
    // InternalMickeyLang.g:3666:1: rule__ActionStatement__Group__5__Impl : ( ( rule__ActionStatement__UniqueAssignment_5 )? ) ;
    public final void rule__ActionStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3670:1: ( ( ( rule__ActionStatement__UniqueAssignment_5 )? ) )
            // InternalMickeyLang.g:3671:1: ( ( rule__ActionStatement__UniqueAssignment_5 )? )
            {
            // InternalMickeyLang.g:3671:1: ( ( rule__ActionStatement__UniqueAssignment_5 )? )
            // InternalMickeyLang.g:3672:2: ( rule__ActionStatement__UniqueAssignment_5 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getUniqueAssignment_5()); 
            }
            // InternalMickeyLang.g:3673:2: ( rule__ActionStatement__UniqueAssignment_5 )?
            int alt43=2;
            int LA43_0 = input.LA(1);

            if ( (LA43_0==105) ) {
                alt43=1;
            }
            switch (alt43) {
                case 1 :
                    // InternalMickeyLang.g:3673:3: rule__ActionStatement__UniqueAssignment_5
                    {
                    pushFollow(FOLLOW_2);
                    rule__ActionStatement__UniqueAssignment_5();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getUniqueAssignment_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__5__Impl"


    // $ANTLR start "rule__ActionStatement__Group__6"
    // InternalMickeyLang.g:3681:1: rule__ActionStatement__Group__6 : rule__ActionStatement__Group__6__Impl ;
    public final void rule__ActionStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3685:1: ( rule__ActionStatement__Group__6__Impl )
            // InternalMickeyLang.g:3686:2: rule__ActionStatement__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__6"


    // $ANTLR start "rule__ActionStatement__Group__6__Impl"
    // InternalMickeyLang.g:3692:1: rule__ActionStatement__Group__6__Impl : ( ( rule__ActionStatement__Group_6__0 )? ) ;
    public final void rule__ActionStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3696:1: ( ( ( rule__ActionStatement__Group_6__0 )? ) )
            // InternalMickeyLang.g:3697:1: ( ( rule__ActionStatement__Group_6__0 )? )
            {
            // InternalMickeyLang.g:3697:1: ( ( rule__ActionStatement__Group_6__0 )? )
            // InternalMickeyLang.g:3698:2: ( rule__ActionStatement__Group_6__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getGroup_6()); 
            }
            // InternalMickeyLang.g:3699:2: ( rule__ActionStatement__Group_6__0 )?
            int alt44=2;
            int LA44_0 = input.LA(1);

            if ( (LA44_0==64) ) {
                alt44=1;
            }
            switch (alt44) {
                case 1 :
                    // InternalMickeyLang.g:3699:3: rule__ActionStatement__Group_6__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ActionStatement__Group_6__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getGroup_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group__6__Impl"


    // $ANTLR start "rule__ActionStatement__Group_6__0"
    // InternalMickeyLang.g:3708:1: rule__ActionStatement__Group_6__0 : rule__ActionStatement__Group_6__0__Impl rule__ActionStatement__Group_6__1 ;
    public final void rule__ActionStatement__Group_6__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3712:1: ( rule__ActionStatement__Group_6__0__Impl rule__ActionStatement__Group_6__1 )
            // InternalMickeyLang.g:3713:2: rule__ActionStatement__Group_6__0__Impl rule__ActionStatement__Group_6__1
            {
            pushFollow(FOLLOW_18);
            rule__ActionStatement__Group_6__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group_6__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__0"


    // $ANTLR start "rule__ActionStatement__Group_6__0__Impl"
    // InternalMickeyLang.g:3720:1: rule__ActionStatement__Group_6__0__Impl : ( '{' ) ;
    public final void rule__ActionStatement__Group_6__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3724:1: ( ( '{' ) )
            // InternalMickeyLang.g:3725:1: ( '{' )
            {
            // InternalMickeyLang.g:3725:1: ( '{' )
            // InternalMickeyLang.g:3726:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getLeftCurlyBracketKeyword_6_0()); 
            }
            match(input,64,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getLeftCurlyBracketKeyword_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__0__Impl"


    // $ANTLR start "rule__ActionStatement__Group_6__1"
    // InternalMickeyLang.g:3735:1: rule__ActionStatement__Group_6__1 : rule__ActionStatement__Group_6__1__Impl rule__ActionStatement__Group_6__2 ;
    public final void rule__ActionStatement__Group_6__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3739:1: ( rule__ActionStatement__Group_6__1__Impl rule__ActionStatement__Group_6__2 )
            // InternalMickeyLang.g:3740:2: rule__ActionStatement__Group_6__1__Impl rule__ActionStatement__Group_6__2
            {
            pushFollow(FOLLOW_18);
            rule__ActionStatement__Group_6__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group_6__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__1"


    // $ANTLR start "rule__ActionStatement__Group_6__1__Impl"
    // InternalMickeyLang.g:3747:1: rule__ActionStatement__Group_6__1__Impl : ( ( rule__ActionStatement__ParamsAssignment_6_1 )* ) ;
    public final void rule__ActionStatement__Group_6__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3751:1: ( ( ( rule__ActionStatement__ParamsAssignment_6_1 )* ) )
            // InternalMickeyLang.g:3752:1: ( ( rule__ActionStatement__ParamsAssignment_6_1 )* )
            {
            // InternalMickeyLang.g:3752:1: ( ( rule__ActionStatement__ParamsAssignment_6_1 )* )
            // InternalMickeyLang.g:3753:2: ( rule__ActionStatement__ParamsAssignment_6_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getParamsAssignment_6_1()); 
            }
            // InternalMickeyLang.g:3754:2: ( rule__ActionStatement__ParamsAssignment_6_1 )*
            loop45:
            do {
                int alt45=2;
                int LA45_0 = input.LA(1);

                if ( (LA45_0==71) ) {
                    alt45=1;
                }


                switch (alt45) {
            	case 1 :
            	    // InternalMickeyLang.g:3754:3: rule__ActionStatement__ParamsAssignment_6_1
            	    {
            	    pushFollow(FOLLOW_19);
            	    rule__ActionStatement__ParamsAssignment_6_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getParamsAssignment_6_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__1__Impl"


    // $ANTLR start "rule__ActionStatement__Group_6__2"
    // InternalMickeyLang.g:3762:1: rule__ActionStatement__Group_6__2 : rule__ActionStatement__Group_6__2__Impl rule__ActionStatement__Group_6__3 ;
    public final void rule__ActionStatement__Group_6__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3766:1: ( rule__ActionStatement__Group_6__2__Impl rule__ActionStatement__Group_6__3 )
            // InternalMickeyLang.g:3767:2: rule__ActionStatement__Group_6__2__Impl rule__ActionStatement__Group_6__3
            {
            pushFollow(FOLLOW_18);
            rule__ActionStatement__Group_6__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group_6__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__2"


    // $ANTLR start "rule__ActionStatement__Group_6__2__Impl"
    // InternalMickeyLang.g:3774:1: rule__ActionStatement__Group_6__2__Impl : ( ( rule__ActionStatement__NotificationsAssignment_6_2 )* ) ;
    public final void rule__ActionStatement__Group_6__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3778:1: ( ( ( rule__ActionStatement__NotificationsAssignment_6_2 )* ) )
            // InternalMickeyLang.g:3779:1: ( ( rule__ActionStatement__NotificationsAssignment_6_2 )* )
            {
            // InternalMickeyLang.g:3779:1: ( ( rule__ActionStatement__NotificationsAssignment_6_2 )* )
            // InternalMickeyLang.g:3780:2: ( rule__ActionStatement__NotificationsAssignment_6_2 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getNotificationsAssignment_6_2()); 
            }
            // InternalMickeyLang.g:3781:2: ( rule__ActionStatement__NotificationsAssignment_6_2 )*
            loop46:
            do {
                int alt46=2;
                int LA46_0 = input.LA(1);

                if ( (LA46_0==70) ) {
                    alt46=1;
                }


                switch (alt46) {
            	case 1 :
            	    // InternalMickeyLang.g:3781:3: rule__ActionStatement__NotificationsAssignment_6_2
            	    {
            	    pushFollow(FOLLOW_20);
            	    rule__ActionStatement__NotificationsAssignment_6_2();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop46;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getNotificationsAssignment_6_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__2__Impl"


    // $ANTLR start "rule__ActionStatement__Group_6__3"
    // InternalMickeyLang.g:3789:1: rule__ActionStatement__Group_6__3 : rule__ActionStatement__Group_6__3__Impl ;
    public final void rule__ActionStatement__Group_6__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3793:1: ( rule__ActionStatement__Group_6__3__Impl )
            // InternalMickeyLang.g:3794:2: rule__ActionStatement__Group_6__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ActionStatement__Group_6__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__3"


    // $ANTLR start "rule__ActionStatement__Group_6__3__Impl"
    // InternalMickeyLang.g:3800:1: rule__ActionStatement__Group_6__3__Impl : ( '}' ) ;
    public final void rule__ActionStatement__Group_6__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3804:1: ( ( '}' ) )
            // InternalMickeyLang.g:3805:1: ( '}' )
            {
            // InternalMickeyLang.g:3805:1: ( '}' )
            // InternalMickeyLang.g:3806:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getRightCurlyBracketKeyword_6_3()); 
            }
            match(input,65,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getRightCurlyBracketKeyword_6_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__Group_6__3__Impl"


    // $ANTLR start "rule__ContentNotificationUri__Group__0"
    // InternalMickeyLang.g:3816:1: rule__ContentNotificationUri__Group__0 : rule__ContentNotificationUri__Group__0__Impl rule__ContentNotificationUri__Group__1 ;
    public final void rule__ContentNotificationUri__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3820:1: ( rule__ContentNotificationUri__Group__0__Impl rule__ContentNotificationUri__Group__1 )
            // InternalMickeyLang.g:3821:2: rule__ContentNotificationUri__Group__0__Impl rule__ContentNotificationUri__Group__1
            {
            pushFollow(FOLLOW_15);
            rule__ContentNotificationUri__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentNotificationUri__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentNotificationUri__Group__0"


    // $ANTLR start "rule__ContentNotificationUri__Group__0__Impl"
    // InternalMickeyLang.g:3828:1: rule__ContentNotificationUri__Group__0__Impl : ( 'notify' ) ;
    public final void rule__ContentNotificationUri__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3832:1: ( ( 'notify' ) )
            // InternalMickeyLang.g:3833:1: ( 'notify' )
            {
            // InternalMickeyLang.g:3833:1: ( 'notify' )
            // InternalMickeyLang.g:3834:2: 'notify'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentNotificationUriAccess().getNotifyKeyword_0()); 
            }
            match(input,70,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentNotificationUriAccess().getNotifyKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentNotificationUri__Group__0__Impl"


    // $ANTLR start "rule__ContentNotificationUri__Group__1"
    // InternalMickeyLang.g:3843:1: rule__ContentNotificationUri__Group__1 : rule__ContentNotificationUri__Group__1__Impl ;
    public final void rule__ContentNotificationUri__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3847:1: ( rule__ContentNotificationUri__Group__1__Impl )
            // InternalMickeyLang.g:3848:2: rule__ContentNotificationUri__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ContentNotificationUri__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentNotificationUri__Group__1"


    // $ANTLR start "rule__ContentNotificationUri__Group__1__Impl"
    // InternalMickeyLang.g:3854:1: rule__ContentNotificationUri__Group__1__Impl : ( ( rule__ContentNotificationUri__UriAssignment_1 ) ) ;
    public final void rule__ContentNotificationUri__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3858:1: ( ( ( rule__ContentNotificationUri__UriAssignment_1 ) ) )
            // InternalMickeyLang.g:3859:1: ( ( rule__ContentNotificationUri__UriAssignment_1 ) )
            {
            // InternalMickeyLang.g:3859:1: ( ( rule__ContentNotificationUri__UriAssignment_1 ) )
            // InternalMickeyLang.g:3860:2: ( rule__ContentNotificationUri__UriAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentNotificationUriAccess().getUriAssignment_1()); 
            }
            // InternalMickeyLang.g:3861:2: ( rule__ContentNotificationUri__UriAssignment_1 )
            // InternalMickeyLang.g:3861:3: rule__ContentNotificationUri__UriAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ContentNotificationUri__UriAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentNotificationUriAccess().getUriAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentNotificationUri__Group__1__Impl"


    // $ANTLR start "rule__FunctionArg__Group__0"
    // InternalMickeyLang.g:3870:1: rule__FunctionArg__Group__0 : rule__FunctionArg__Group__0__Impl rule__FunctionArg__Group__1 ;
    public final void rule__FunctionArg__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3874:1: ( rule__FunctionArg__Group__0__Impl rule__FunctionArg__Group__1 )
            // InternalMickeyLang.g:3875:2: rule__FunctionArg__Group__0__Impl rule__FunctionArg__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__FunctionArg__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__FunctionArg__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionArg__Group__0"


    // $ANTLR start "rule__FunctionArg__Group__0__Impl"
    // InternalMickeyLang.g:3882:1: rule__FunctionArg__Group__0__Impl : ( ( rule__FunctionArg__TypeAssignment_0 ) ) ;
    public final void rule__FunctionArg__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3886:1: ( ( ( rule__FunctionArg__TypeAssignment_0 ) ) )
            // InternalMickeyLang.g:3887:1: ( ( rule__FunctionArg__TypeAssignment_0 ) )
            {
            // InternalMickeyLang.g:3887:1: ( ( rule__FunctionArg__TypeAssignment_0 ) )
            // InternalMickeyLang.g:3888:2: ( rule__FunctionArg__TypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFunctionArgAccess().getTypeAssignment_0()); 
            }
            // InternalMickeyLang.g:3889:2: ( rule__FunctionArg__TypeAssignment_0 )
            // InternalMickeyLang.g:3889:3: rule__FunctionArg__TypeAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__FunctionArg__TypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getFunctionArgAccess().getTypeAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionArg__Group__0__Impl"


    // $ANTLR start "rule__FunctionArg__Group__1"
    // InternalMickeyLang.g:3897:1: rule__FunctionArg__Group__1 : rule__FunctionArg__Group__1__Impl ;
    public final void rule__FunctionArg__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3901:1: ( rule__FunctionArg__Group__1__Impl )
            // InternalMickeyLang.g:3902:2: rule__FunctionArg__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__FunctionArg__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionArg__Group__1"


    // $ANTLR start "rule__FunctionArg__Group__1__Impl"
    // InternalMickeyLang.g:3908:1: rule__FunctionArg__Group__1__Impl : ( ( rule__FunctionArg__NameAssignment_1 ) ) ;
    public final void rule__FunctionArg__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3912:1: ( ( ( rule__FunctionArg__NameAssignment_1 ) ) )
            // InternalMickeyLang.g:3913:1: ( ( rule__FunctionArg__NameAssignment_1 ) )
            {
            // InternalMickeyLang.g:3913:1: ( ( rule__FunctionArg__NameAssignment_1 ) )
            // InternalMickeyLang.g:3914:2: ( rule__FunctionArg__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFunctionArgAccess().getNameAssignment_1()); 
            }
            // InternalMickeyLang.g:3915:2: ( rule__FunctionArg__NameAssignment_1 )
            // InternalMickeyLang.g:3915:3: rule__FunctionArg__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__FunctionArg__NameAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getFunctionArgAccess().getNameAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionArg__Group__1__Impl"


    // $ANTLR start "rule__NotifyContentUri__Group__0"
    // InternalMickeyLang.g:3924:1: rule__NotifyContentUri__Group__0 : rule__NotifyContentUri__Group__0__Impl rule__NotifyContentUri__Group__1 ;
    public final void rule__NotifyContentUri__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3928:1: ( rule__NotifyContentUri__Group__0__Impl rule__NotifyContentUri__Group__1 )
            // InternalMickeyLang.g:3929:2: rule__NotifyContentUri__Group__0__Impl rule__NotifyContentUri__Group__1
            {
            pushFollow(FOLLOW_15);
            rule__NotifyContentUri__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group__0"


    // $ANTLR start "rule__NotifyContentUri__Group__0__Impl"
    // InternalMickeyLang.g:3936:1: rule__NotifyContentUri__Group__0__Impl : ( () ) ;
    public final void rule__NotifyContentUri__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3940:1: ( ( () ) )
            // InternalMickeyLang.g:3941:1: ( () )
            {
            // InternalMickeyLang.g:3941:1: ( () )
            // InternalMickeyLang.g:3942:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getNotifyContentUriAction_0()); 
            }
            // InternalMickeyLang.g:3943:2: ()
            // InternalMickeyLang.g:3943:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getNotifyContentUriAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group__0__Impl"


    // $ANTLR start "rule__NotifyContentUri__Group__1"
    // InternalMickeyLang.g:3951:1: rule__NotifyContentUri__Group__1 : rule__NotifyContentUri__Group__1__Impl rule__NotifyContentUri__Group__2 ;
    public final void rule__NotifyContentUri__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3955:1: ( rule__NotifyContentUri__Group__1__Impl rule__NotifyContentUri__Group__2 )
            // InternalMickeyLang.g:3956:2: rule__NotifyContentUri__Group__1__Impl rule__NotifyContentUri__Group__2
            {
            pushFollow(FOLLOW_15);
            rule__NotifyContentUri__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group__1"


    // $ANTLR start "rule__NotifyContentUri__Group__1__Impl"
    // InternalMickeyLang.g:3963:1: rule__NotifyContentUri__Group__1__Impl : ( ( rule__NotifyContentUri__SegmentsAssignment_1 )? ) ;
    public final void rule__NotifyContentUri__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3967:1: ( ( ( rule__NotifyContentUri__SegmentsAssignment_1 )? ) )
            // InternalMickeyLang.g:3968:1: ( ( rule__NotifyContentUri__SegmentsAssignment_1 )? )
            {
            // InternalMickeyLang.g:3968:1: ( ( rule__NotifyContentUri__SegmentsAssignment_1 )? )
            // InternalMickeyLang.g:3969:2: ( rule__NotifyContentUri__SegmentsAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getSegmentsAssignment_1()); 
            }
            // InternalMickeyLang.g:3970:2: ( rule__NotifyContentUri__SegmentsAssignment_1 )?
            int alt47=2;
            int LA47_0 = input.LA(1);

            if ( (LA47_0==RULE_ID||LA47_0==64) ) {
                alt47=1;
            }
            switch (alt47) {
                case 1 :
                    // InternalMickeyLang.g:3970:3: rule__NotifyContentUri__SegmentsAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__NotifyContentUri__SegmentsAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getSegmentsAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group__1__Impl"


    // $ANTLR start "rule__NotifyContentUri__Group__2"
    // InternalMickeyLang.g:3978:1: rule__NotifyContentUri__Group__2 : rule__NotifyContentUri__Group__2__Impl ;
    public final void rule__NotifyContentUri__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3982:1: ( rule__NotifyContentUri__Group__2__Impl )
            // InternalMickeyLang.g:3983:2: rule__NotifyContentUri__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group__2"


    // $ANTLR start "rule__NotifyContentUri__Group__2__Impl"
    // InternalMickeyLang.g:3989:1: rule__NotifyContentUri__Group__2__Impl : ( ( rule__NotifyContentUri__Group_2__0 )* ) ;
    public final void rule__NotifyContentUri__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:3993:1: ( ( ( rule__NotifyContentUri__Group_2__0 )* ) )
            // InternalMickeyLang.g:3994:1: ( ( rule__NotifyContentUri__Group_2__0 )* )
            {
            // InternalMickeyLang.g:3994:1: ( ( rule__NotifyContentUri__Group_2__0 )* )
            // InternalMickeyLang.g:3995:2: ( rule__NotifyContentUri__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getGroup_2()); 
            }
            // InternalMickeyLang.g:3996:2: ( rule__NotifyContentUri__Group_2__0 )*
            loop48:
            do {
                int alt48=2;
                int LA48_0 = input.LA(1);

                if ( (LA48_0==13) ) {
                    alt48=1;
                }


                switch (alt48) {
            	case 1 :
            	    // InternalMickeyLang.g:3996:3: rule__NotifyContentUri__Group_2__0
            	    {
            	    pushFollow(FOLLOW_21);
            	    rule__NotifyContentUri__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop48;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getGroup_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group__2__Impl"


    // $ANTLR start "rule__NotifyContentUri__Group_2__0"
    // InternalMickeyLang.g:4005:1: rule__NotifyContentUri__Group_2__0 : rule__NotifyContentUri__Group_2__0__Impl rule__NotifyContentUri__Group_2__1 ;
    public final void rule__NotifyContentUri__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4009:1: ( rule__NotifyContentUri__Group_2__0__Impl rule__NotifyContentUri__Group_2__1 )
            // InternalMickeyLang.g:4010:2: rule__NotifyContentUri__Group_2__0__Impl rule__NotifyContentUri__Group_2__1
            {
            pushFollow(FOLLOW_22);
            rule__NotifyContentUri__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group_2__0"


    // $ANTLR start "rule__NotifyContentUri__Group_2__0__Impl"
    // InternalMickeyLang.g:4017:1: rule__NotifyContentUri__Group_2__0__Impl : ( '/' ) ;
    public final void rule__NotifyContentUri__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4021:1: ( ( '/' ) )
            // InternalMickeyLang.g:4022:1: ( '/' )
            {
            // InternalMickeyLang.g:4022:1: ( '/' )
            // InternalMickeyLang.g:4023:2: '/'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getSolidusKeyword_2_0()); 
            }
            match(input,13,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getSolidusKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group_2__0__Impl"


    // $ANTLR start "rule__NotifyContentUri__Group_2__1"
    // InternalMickeyLang.g:4032:1: rule__NotifyContentUri__Group_2__1 : rule__NotifyContentUri__Group_2__1__Impl ;
    public final void rule__NotifyContentUri__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4036:1: ( rule__NotifyContentUri__Group_2__1__Impl )
            // InternalMickeyLang.g:4037:2: rule__NotifyContentUri__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group_2__1"


    // $ANTLR start "rule__NotifyContentUri__Group_2__1__Impl"
    // InternalMickeyLang.g:4043:1: rule__NotifyContentUri__Group_2__1__Impl : ( ( rule__NotifyContentUri__SegmentsAssignment_2_1 ) ) ;
    public final void rule__NotifyContentUri__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4047:1: ( ( ( rule__NotifyContentUri__SegmentsAssignment_2_1 ) ) )
            // InternalMickeyLang.g:4048:1: ( ( rule__NotifyContentUri__SegmentsAssignment_2_1 ) )
            {
            // InternalMickeyLang.g:4048:1: ( ( rule__NotifyContentUri__SegmentsAssignment_2_1 ) )
            // InternalMickeyLang.g:4049:2: ( rule__NotifyContentUri__SegmentsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getSegmentsAssignment_2_1()); 
            }
            // InternalMickeyLang.g:4050:2: ( rule__NotifyContentUri__SegmentsAssignment_2_1 )
            // InternalMickeyLang.g:4050:3: rule__NotifyContentUri__SegmentsAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUri__SegmentsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getSegmentsAssignment_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__Group_2__1__Impl"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__0"
    // InternalMickeyLang.g:4059:1: rule__NotifyContentUriSegment__Group_1__0 : rule__NotifyContentUriSegment__Group_1__0__Impl rule__NotifyContentUriSegment__Group_1__1 ;
    public final void rule__NotifyContentUriSegment__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4063:1: ( rule__NotifyContentUriSegment__Group_1__0__Impl rule__NotifyContentUriSegment__Group_1__1 )
            // InternalMickeyLang.g:4064:2: rule__NotifyContentUriSegment__Group_1__0__Impl rule__NotifyContentUriSegment__Group_1__1
            {
            pushFollow(FOLLOW_22);
            rule__NotifyContentUriSegment__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NotifyContentUriSegment__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__0"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__0__Impl"
    // InternalMickeyLang.g:4071:1: rule__NotifyContentUriSegment__Group_1__0__Impl : ( () ) ;
    public final void rule__NotifyContentUriSegment__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4075:1: ( ( () ) )
            // InternalMickeyLang.g:4076:1: ( () )
            {
            // InternalMickeyLang.g:4076:1: ( () )
            // InternalMickeyLang.g:4077:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getNotifyContentUriParamSegmentAction_1_0()); 
            }
            // InternalMickeyLang.g:4078:2: ()
            // InternalMickeyLang.g:4078:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getNotifyContentUriParamSegmentAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__0__Impl"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__1"
    // InternalMickeyLang.g:4086:1: rule__NotifyContentUriSegment__Group_1__1 : rule__NotifyContentUriSegment__Group_1__1__Impl rule__NotifyContentUriSegment__Group_1__2 ;
    public final void rule__NotifyContentUriSegment__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4090:1: ( rule__NotifyContentUriSegment__Group_1__1__Impl rule__NotifyContentUriSegment__Group_1__2 )
            // InternalMickeyLang.g:4091:2: rule__NotifyContentUriSegment__Group_1__1__Impl rule__NotifyContentUriSegment__Group_1__2
            {
            pushFollow(FOLLOW_3);
            rule__NotifyContentUriSegment__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NotifyContentUriSegment__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__1"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__1__Impl"
    // InternalMickeyLang.g:4098:1: rule__NotifyContentUriSegment__Group_1__1__Impl : ( '{' ) ;
    public final void rule__NotifyContentUriSegment__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4102:1: ( ( '{' ) )
            // InternalMickeyLang.g:4103:1: ( '{' )
            {
            // InternalMickeyLang.g:4103:1: ( '{' )
            // InternalMickeyLang.g:4104:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getLeftCurlyBracketKeyword_1_1()); 
            }
            match(input,64,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getLeftCurlyBracketKeyword_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__1__Impl"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__2"
    // InternalMickeyLang.g:4113:1: rule__NotifyContentUriSegment__Group_1__2 : rule__NotifyContentUriSegment__Group_1__2__Impl rule__NotifyContentUriSegment__Group_1__3 ;
    public final void rule__NotifyContentUriSegment__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4117:1: ( rule__NotifyContentUriSegment__Group_1__2__Impl rule__NotifyContentUriSegment__Group_1__3 )
            // InternalMickeyLang.g:4118:2: rule__NotifyContentUriSegment__Group_1__2__Impl rule__NotifyContentUriSegment__Group_1__3
            {
            pushFollow(FOLLOW_23);
            rule__NotifyContentUriSegment__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NotifyContentUriSegment__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__2"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__2__Impl"
    // InternalMickeyLang.g:4125:1: rule__NotifyContentUriSegment__Group_1__2__Impl : ( ( rule__NotifyContentUriSegment__NameAssignment_1_2 ) ) ;
    public final void rule__NotifyContentUriSegment__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4129:1: ( ( ( rule__NotifyContentUriSegment__NameAssignment_1_2 ) ) )
            // InternalMickeyLang.g:4130:1: ( ( rule__NotifyContentUriSegment__NameAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:4130:1: ( ( rule__NotifyContentUriSegment__NameAssignment_1_2 ) )
            // InternalMickeyLang.g:4131:2: ( rule__NotifyContentUriSegment__NameAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getNameAssignment_1_2()); 
            }
            // InternalMickeyLang.g:4132:2: ( rule__NotifyContentUriSegment__NameAssignment_1_2 )
            // InternalMickeyLang.g:4132:3: rule__NotifyContentUriSegment__NameAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUriSegment__NameAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getNameAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__2__Impl"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__3"
    // InternalMickeyLang.g:4140:1: rule__NotifyContentUriSegment__Group_1__3 : rule__NotifyContentUriSegment__Group_1__3__Impl ;
    public final void rule__NotifyContentUriSegment__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4144:1: ( rule__NotifyContentUriSegment__Group_1__3__Impl )
            // InternalMickeyLang.g:4145:2: rule__NotifyContentUriSegment__Group_1__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NotifyContentUriSegment__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__3"


    // $ANTLR start "rule__NotifyContentUriSegment__Group_1__3__Impl"
    // InternalMickeyLang.g:4151:1: rule__NotifyContentUriSegment__Group_1__3__Impl : ( '}' ) ;
    public final void rule__NotifyContentUriSegment__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4155:1: ( ( '}' ) )
            // InternalMickeyLang.g:4156:1: ( '}' )
            {
            // InternalMickeyLang.g:4156:1: ( '}' )
            // InternalMickeyLang.g:4157:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getRightCurlyBracketKeyword_1_3()); 
            }
            match(input,65,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getRightCurlyBracketKeyword_1_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__Group_1__3__Impl"


    // $ANTLR start "rule__ContentUri__Group__0"
    // InternalMickeyLang.g:4167:1: rule__ContentUri__Group__0 : rule__ContentUri__Group__0__Impl rule__ContentUri__Group__1 ;
    public final void rule__ContentUri__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4171:1: ( rule__ContentUri__Group__0__Impl rule__ContentUri__Group__1 )
            // InternalMickeyLang.g:4172:2: rule__ContentUri__Group__0__Impl rule__ContentUri__Group__1
            {
            pushFollow(FOLLOW_15);
            rule__ContentUri__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUri__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group__0"


    // $ANTLR start "rule__ContentUri__Group__0__Impl"
    // InternalMickeyLang.g:4179:1: rule__ContentUri__Group__0__Impl : ( () ) ;
    public final void rule__ContentUri__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4183:1: ( ( () ) )
            // InternalMickeyLang.g:4184:1: ( () )
            {
            // InternalMickeyLang.g:4184:1: ( () )
            // InternalMickeyLang.g:4185:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getContentUriAction_0()); 
            }
            // InternalMickeyLang.g:4186:2: ()
            // InternalMickeyLang.g:4186:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getContentUriAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group__0__Impl"


    // $ANTLR start "rule__ContentUri__Group__1"
    // InternalMickeyLang.g:4194:1: rule__ContentUri__Group__1 : rule__ContentUri__Group__1__Impl rule__ContentUri__Group__2 ;
    public final void rule__ContentUri__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4198:1: ( rule__ContentUri__Group__1__Impl rule__ContentUri__Group__2 )
            // InternalMickeyLang.g:4199:2: rule__ContentUri__Group__1__Impl rule__ContentUri__Group__2
            {
            pushFollow(FOLLOW_15);
            rule__ContentUri__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUri__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group__1"


    // $ANTLR start "rule__ContentUri__Group__1__Impl"
    // InternalMickeyLang.g:4206:1: rule__ContentUri__Group__1__Impl : ( ( rule__ContentUri__SegmentsAssignment_1 )? ) ;
    public final void rule__ContentUri__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4210:1: ( ( ( rule__ContentUri__SegmentsAssignment_1 )? ) )
            // InternalMickeyLang.g:4211:1: ( ( rule__ContentUri__SegmentsAssignment_1 )? )
            {
            // InternalMickeyLang.g:4211:1: ( ( rule__ContentUri__SegmentsAssignment_1 )? )
            // InternalMickeyLang.g:4212:2: ( rule__ContentUri__SegmentsAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getSegmentsAssignment_1()); 
            }
            // InternalMickeyLang.g:4213:2: ( rule__ContentUri__SegmentsAssignment_1 )?
            int alt49=2;
            int LA49_0 = input.LA(1);

            if ( (LA49_0==RULE_ID||LA49_0==64) ) {
                alt49=1;
            }
            switch (alt49) {
                case 1 :
                    // InternalMickeyLang.g:4213:3: rule__ContentUri__SegmentsAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ContentUri__SegmentsAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getSegmentsAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group__1__Impl"


    // $ANTLR start "rule__ContentUri__Group__2"
    // InternalMickeyLang.g:4221:1: rule__ContentUri__Group__2 : rule__ContentUri__Group__2__Impl ;
    public final void rule__ContentUri__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4225:1: ( rule__ContentUri__Group__2__Impl )
            // InternalMickeyLang.g:4226:2: rule__ContentUri__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ContentUri__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group__2"


    // $ANTLR start "rule__ContentUri__Group__2__Impl"
    // InternalMickeyLang.g:4232:1: rule__ContentUri__Group__2__Impl : ( ( rule__ContentUri__Group_2__0 )* ) ;
    public final void rule__ContentUri__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4236:1: ( ( ( rule__ContentUri__Group_2__0 )* ) )
            // InternalMickeyLang.g:4237:1: ( ( rule__ContentUri__Group_2__0 )* )
            {
            // InternalMickeyLang.g:4237:1: ( ( rule__ContentUri__Group_2__0 )* )
            // InternalMickeyLang.g:4238:2: ( rule__ContentUri__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getGroup_2()); 
            }
            // InternalMickeyLang.g:4239:2: ( rule__ContentUri__Group_2__0 )*
            loop50:
            do {
                int alt50=2;
                int LA50_0 = input.LA(1);

                if ( (LA50_0==13) ) {
                    alt50=1;
                }


                switch (alt50) {
            	case 1 :
            	    // InternalMickeyLang.g:4239:3: rule__ContentUri__Group_2__0
            	    {
            	    pushFollow(FOLLOW_21);
            	    rule__ContentUri__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop50;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getGroup_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group__2__Impl"


    // $ANTLR start "rule__ContentUri__Group_2__0"
    // InternalMickeyLang.g:4248:1: rule__ContentUri__Group_2__0 : rule__ContentUri__Group_2__0__Impl rule__ContentUri__Group_2__1 ;
    public final void rule__ContentUri__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4252:1: ( rule__ContentUri__Group_2__0__Impl rule__ContentUri__Group_2__1 )
            // InternalMickeyLang.g:4253:2: rule__ContentUri__Group_2__0__Impl rule__ContentUri__Group_2__1
            {
            pushFollow(FOLLOW_22);
            rule__ContentUri__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUri__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group_2__0"


    // $ANTLR start "rule__ContentUri__Group_2__0__Impl"
    // InternalMickeyLang.g:4260:1: rule__ContentUri__Group_2__0__Impl : ( '/' ) ;
    public final void rule__ContentUri__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4264:1: ( ( '/' ) )
            // InternalMickeyLang.g:4265:1: ( '/' )
            {
            // InternalMickeyLang.g:4265:1: ( '/' )
            // InternalMickeyLang.g:4266:2: '/'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getSolidusKeyword_2_0()); 
            }
            match(input,13,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getSolidusKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group_2__0__Impl"


    // $ANTLR start "rule__ContentUri__Group_2__1"
    // InternalMickeyLang.g:4275:1: rule__ContentUri__Group_2__1 : rule__ContentUri__Group_2__1__Impl ;
    public final void rule__ContentUri__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4279:1: ( rule__ContentUri__Group_2__1__Impl )
            // InternalMickeyLang.g:4280:2: rule__ContentUri__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ContentUri__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group_2__1"


    // $ANTLR start "rule__ContentUri__Group_2__1__Impl"
    // InternalMickeyLang.g:4286:1: rule__ContentUri__Group_2__1__Impl : ( ( rule__ContentUri__SegmentsAssignment_2_1 ) ) ;
    public final void rule__ContentUri__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4290:1: ( ( ( rule__ContentUri__SegmentsAssignment_2_1 ) ) )
            // InternalMickeyLang.g:4291:1: ( ( rule__ContentUri__SegmentsAssignment_2_1 ) )
            {
            // InternalMickeyLang.g:4291:1: ( ( rule__ContentUri__SegmentsAssignment_2_1 ) )
            // InternalMickeyLang.g:4292:2: ( rule__ContentUri__SegmentsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getSegmentsAssignment_2_1()); 
            }
            // InternalMickeyLang.g:4293:2: ( rule__ContentUri__SegmentsAssignment_2_1 )
            // InternalMickeyLang.g:4293:3: rule__ContentUri__SegmentsAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__ContentUri__SegmentsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getSegmentsAssignment_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__Group_2__1__Impl"


    // $ANTLR start "rule__ContentUriQueryParam__Group__0"
    // InternalMickeyLang.g:4302:1: rule__ContentUriQueryParam__Group__0 : rule__ContentUriQueryParam__Group__0__Impl rule__ContentUriQueryParam__Group__1 ;
    public final void rule__ContentUriQueryParam__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4306:1: ( rule__ContentUriQueryParam__Group__0__Impl rule__ContentUriQueryParam__Group__1 )
            // InternalMickeyLang.g:4307:2: rule__ContentUriQueryParam__Group__0__Impl rule__ContentUriQueryParam__Group__1
            {
            pushFollow(FOLLOW_24);
            rule__ContentUriQueryParam__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUriQueryParam__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__Group__0"


    // $ANTLR start "rule__ContentUriQueryParam__Group__0__Impl"
    // InternalMickeyLang.g:4314:1: rule__ContentUriQueryParam__Group__0__Impl : ( 'param' ) ;
    public final void rule__ContentUriQueryParam__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4318:1: ( ( 'param' ) )
            // InternalMickeyLang.g:4319:1: ( 'param' )
            {
            // InternalMickeyLang.g:4319:1: ( 'param' )
            // InternalMickeyLang.g:4320:2: 'param'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getParamKeyword_0()); 
            }
            match(input,71,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getParamKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__Group__0__Impl"


    // $ANTLR start "rule__ContentUriQueryParam__Group__1"
    // InternalMickeyLang.g:4329:1: rule__ContentUriQueryParam__Group__1 : rule__ContentUriQueryParam__Group__1__Impl rule__ContentUriQueryParam__Group__2 ;
    public final void rule__ContentUriQueryParam__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4333:1: ( rule__ContentUriQueryParam__Group__1__Impl rule__ContentUriQueryParam__Group__2 )
            // InternalMickeyLang.g:4334:2: rule__ContentUriQueryParam__Group__1__Impl rule__ContentUriQueryParam__Group__2
            {
            pushFollow(FOLLOW_24);
            rule__ContentUriQueryParam__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUriQueryParam__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__Group__1"


    // $ANTLR start "rule__ContentUriQueryParam__Group__1__Impl"
    // InternalMickeyLang.g:4341:1: rule__ContentUriQueryParam__Group__1__Impl : ( ( rule__ContentUriQueryParam__LikeAssignment_1 )? ) ;
    public final void rule__ContentUriQueryParam__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4345:1: ( ( ( rule__ContentUriQueryParam__LikeAssignment_1 )? ) )
            // InternalMickeyLang.g:4346:1: ( ( rule__ContentUriQueryParam__LikeAssignment_1 )? )
            {
            // InternalMickeyLang.g:4346:1: ( ( rule__ContentUriQueryParam__LikeAssignment_1 )? )
            // InternalMickeyLang.g:4347:2: ( rule__ContentUriQueryParam__LikeAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getLikeAssignment_1()); 
            }
            // InternalMickeyLang.g:4348:2: ( rule__ContentUriQueryParam__LikeAssignment_1 )?
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==33) ) {
                alt51=1;
            }
            switch (alt51) {
                case 1 :
                    // InternalMickeyLang.g:4348:3: rule__ContentUriQueryParam__LikeAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ContentUriQueryParam__LikeAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getLikeAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__Group__1__Impl"


    // $ANTLR start "rule__ContentUriQueryParam__Group__2"
    // InternalMickeyLang.g:4356:1: rule__ContentUriQueryParam__Group__2 : rule__ContentUriQueryParam__Group__2__Impl ;
    public final void rule__ContentUriQueryParam__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4360:1: ( rule__ContentUriQueryParam__Group__2__Impl )
            // InternalMickeyLang.g:4361:2: rule__ContentUriQueryParam__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ContentUriQueryParam__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__Group__2"


    // $ANTLR start "rule__ContentUriQueryParam__Group__2__Impl"
    // InternalMickeyLang.g:4367:1: rule__ContentUriQueryParam__Group__2__Impl : ( ( rule__ContentUriQueryParam__ColumnAssignment_2 ) ) ;
    public final void rule__ContentUriQueryParam__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4371:1: ( ( ( rule__ContentUriQueryParam__ColumnAssignment_2 ) ) )
            // InternalMickeyLang.g:4372:1: ( ( rule__ContentUriQueryParam__ColumnAssignment_2 ) )
            {
            // InternalMickeyLang.g:4372:1: ( ( rule__ContentUriQueryParam__ColumnAssignment_2 ) )
            // InternalMickeyLang.g:4373:2: ( rule__ContentUriQueryParam__ColumnAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getColumnAssignment_2()); 
            }
            // InternalMickeyLang.g:4374:2: ( rule__ContentUriQueryParam__ColumnAssignment_2 )
            // InternalMickeyLang.g:4374:3: rule__ContentUriQueryParam__ColumnAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ContentUriQueryParam__ColumnAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getColumnAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__Group__2__Impl"


    // $ANTLR start "rule__ContentUriSegment__Group_1__0"
    // InternalMickeyLang.g:4383:1: rule__ContentUriSegment__Group_1__0 : rule__ContentUriSegment__Group_1__0__Impl rule__ContentUriSegment__Group_1__1 ;
    public final void rule__ContentUriSegment__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4387:1: ( rule__ContentUriSegment__Group_1__0__Impl rule__ContentUriSegment__Group_1__1 )
            // InternalMickeyLang.g:4388:2: rule__ContentUriSegment__Group_1__0__Impl rule__ContentUriSegment__Group_1__1
            {
            pushFollow(FOLLOW_22);
            rule__ContentUriSegment__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUriSegment__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__0"


    // $ANTLR start "rule__ContentUriSegment__Group_1__0__Impl"
    // InternalMickeyLang.g:4395:1: rule__ContentUriSegment__Group_1__0__Impl : ( () ) ;
    public final void rule__ContentUriSegment__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4399:1: ( ( () ) )
            // InternalMickeyLang.g:4400:1: ( () )
            {
            // InternalMickeyLang.g:4400:1: ( () )
            // InternalMickeyLang.g:4401:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getContentUriParamSegmentAction_1_0()); 
            }
            // InternalMickeyLang.g:4402:2: ()
            // InternalMickeyLang.g:4402:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getContentUriParamSegmentAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__0__Impl"


    // $ANTLR start "rule__ContentUriSegment__Group_1__1"
    // InternalMickeyLang.g:4410:1: rule__ContentUriSegment__Group_1__1 : rule__ContentUriSegment__Group_1__1__Impl rule__ContentUriSegment__Group_1__2 ;
    public final void rule__ContentUriSegment__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4414:1: ( rule__ContentUriSegment__Group_1__1__Impl rule__ContentUriSegment__Group_1__2 )
            // InternalMickeyLang.g:4415:2: rule__ContentUriSegment__Group_1__1__Impl rule__ContentUriSegment__Group_1__2
            {
            pushFollow(FOLLOW_3);
            rule__ContentUriSegment__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUriSegment__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__1"


    // $ANTLR start "rule__ContentUriSegment__Group_1__1__Impl"
    // InternalMickeyLang.g:4422:1: rule__ContentUriSegment__Group_1__1__Impl : ( '{' ) ;
    public final void rule__ContentUriSegment__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4426:1: ( ( '{' ) )
            // InternalMickeyLang.g:4427:1: ( '{' )
            {
            // InternalMickeyLang.g:4427:1: ( '{' )
            // InternalMickeyLang.g:4428:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getLeftCurlyBracketKeyword_1_1()); 
            }
            match(input,64,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getLeftCurlyBracketKeyword_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__1__Impl"


    // $ANTLR start "rule__ContentUriSegment__Group_1__2"
    // InternalMickeyLang.g:4437:1: rule__ContentUriSegment__Group_1__2 : rule__ContentUriSegment__Group_1__2__Impl rule__ContentUriSegment__Group_1__3 ;
    public final void rule__ContentUriSegment__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4441:1: ( rule__ContentUriSegment__Group_1__2__Impl rule__ContentUriSegment__Group_1__3 )
            // InternalMickeyLang.g:4442:2: rule__ContentUriSegment__Group_1__2__Impl rule__ContentUriSegment__Group_1__3
            {
            pushFollow(FOLLOW_23);
            rule__ContentUriSegment__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ContentUriSegment__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__2"


    // $ANTLR start "rule__ContentUriSegment__Group_1__2__Impl"
    // InternalMickeyLang.g:4449:1: rule__ContentUriSegment__Group_1__2__Impl : ( ( rule__ContentUriSegment__ParamAssignment_1_2 ) ) ;
    public final void rule__ContentUriSegment__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4453:1: ( ( ( rule__ContentUriSegment__ParamAssignment_1_2 ) ) )
            // InternalMickeyLang.g:4454:1: ( ( rule__ContentUriSegment__ParamAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:4454:1: ( ( rule__ContentUriSegment__ParamAssignment_1_2 ) )
            // InternalMickeyLang.g:4455:2: ( rule__ContentUriSegment__ParamAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getParamAssignment_1_2()); 
            }
            // InternalMickeyLang.g:4456:2: ( rule__ContentUriSegment__ParamAssignment_1_2 )
            // InternalMickeyLang.g:4456:3: rule__ContentUriSegment__ParamAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ContentUriSegment__ParamAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getParamAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__2__Impl"


    // $ANTLR start "rule__ContentUriSegment__Group_1__3"
    // InternalMickeyLang.g:4464:1: rule__ContentUriSegment__Group_1__3 : rule__ContentUriSegment__Group_1__3__Impl ;
    public final void rule__ContentUriSegment__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4468:1: ( rule__ContentUriSegment__Group_1__3__Impl )
            // InternalMickeyLang.g:4469:2: rule__ContentUriSegment__Group_1__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ContentUriSegment__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__3"


    // $ANTLR start "rule__ContentUriSegment__Group_1__3__Impl"
    // InternalMickeyLang.g:4475:1: rule__ContentUriSegment__Group_1__3__Impl : ( '}' ) ;
    public final void rule__ContentUriSegment__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4479:1: ( ( '}' ) )
            // InternalMickeyLang.g:4480:1: ( '}' )
            {
            // InternalMickeyLang.g:4480:1: ( '}' )
            // InternalMickeyLang.g:4481:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getRightCurlyBracketKeyword_1_3()); 
            }
            match(input,65,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getRightCurlyBracketKeyword_1_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__Group_1__3__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__0"
    // InternalMickeyLang.g:4491:1: rule__MigrationBlock__Group__0 : rule__MigrationBlock__Group__0__Impl rule__MigrationBlock__Group__1 ;
    public final void rule__MigrationBlock__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4495:1: ( rule__MigrationBlock__Group__0__Impl rule__MigrationBlock__Group__1 )
            // InternalMickeyLang.g:4496:2: rule__MigrationBlock__Group__0__Impl rule__MigrationBlock__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__MigrationBlock__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__0"


    // $ANTLR start "rule__MigrationBlock__Group__0__Impl"
    // InternalMickeyLang.g:4503:1: rule__MigrationBlock__Group__0__Impl : ( () ) ;
    public final void rule__MigrationBlock__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4507:1: ( ( () ) )
            // InternalMickeyLang.g:4508:1: ( () )
            {
            // InternalMickeyLang.g:4508:1: ( () )
            // InternalMickeyLang.g:4509:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getMigrationBlockAction_0()); 
            }
            // InternalMickeyLang.g:4510:2: ()
            // InternalMickeyLang.g:4510:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getMigrationBlockAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__0__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__1"
    // InternalMickeyLang.g:4518:1: rule__MigrationBlock__Group__1 : rule__MigrationBlock__Group__1__Impl rule__MigrationBlock__Group__2 ;
    public final void rule__MigrationBlock__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4522:1: ( rule__MigrationBlock__Group__1__Impl rule__MigrationBlock__Group__2 )
            // InternalMickeyLang.g:4523:2: rule__MigrationBlock__Group__1__Impl rule__MigrationBlock__Group__2
            {
            pushFollow(FOLLOW_3);
            rule__MigrationBlock__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__1"


    // $ANTLR start "rule__MigrationBlock__Group__1__Impl"
    // InternalMickeyLang.g:4530:1: rule__MigrationBlock__Group__1__Impl : ( 'migrate' ) ;
    public final void rule__MigrationBlock__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4534:1: ( ( 'migrate' ) )
            // InternalMickeyLang.g:4535:1: ( 'migrate' )
            {
            // InternalMickeyLang.g:4535:1: ( 'migrate' )
            // InternalMickeyLang.g:4536:2: 'migrate'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getMigrateKeyword_1()); 
            }
            match(input,72,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getMigrateKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__1__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__2"
    // InternalMickeyLang.g:4545:1: rule__MigrationBlock__Group__2 : rule__MigrationBlock__Group__2__Impl rule__MigrationBlock__Group__3 ;
    public final void rule__MigrationBlock__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4549:1: ( rule__MigrationBlock__Group__2__Impl rule__MigrationBlock__Group__3 )
            // InternalMickeyLang.g:4550:2: rule__MigrationBlock__Group__2__Impl rule__MigrationBlock__Group__3
            {
            pushFollow(FOLLOW_25);
            rule__MigrationBlock__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__2"


    // $ANTLR start "rule__MigrationBlock__Group__2__Impl"
    // InternalMickeyLang.g:4557:1: rule__MigrationBlock__Group__2__Impl : ( ( rule__MigrationBlock__NameAssignment_2 ) ) ;
    public final void rule__MigrationBlock__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4561:1: ( ( ( rule__MigrationBlock__NameAssignment_2 ) ) )
            // InternalMickeyLang.g:4562:1: ( ( rule__MigrationBlock__NameAssignment_2 ) )
            {
            // InternalMickeyLang.g:4562:1: ( ( rule__MigrationBlock__NameAssignment_2 ) )
            // InternalMickeyLang.g:4563:2: ( rule__MigrationBlock__NameAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getNameAssignment_2()); 
            }
            // InternalMickeyLang.g:4564:2: ( rule__MigrationBlock__NameAssignment_2 )
            // InternalMickeyLang.g:4564:3: rule__MigrationBlock__NameAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__NameAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getNameAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__2__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__3"
    // InternalMickeyLang.g:4572:1: rule__MigrationBlock__Group__3 : rule__MigrationBlock__Group__3__Impl rule__MigrationBlock__Group__4 ;
    public final void rule__MigrationBlock__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4576:1: ( rule__MigrationBlock__Group__3__Impl rule__MigrationBlock__Group__4 )
            // InternalMickeyLang.g:4577:2: rule__MigrationBlock__Group__3__Impl rule__MigrationBlock__Group__4
            {
            pushFollow(FOLLOW_25);
            rule__MigrationBlock__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__3"


    // $ANTLR start "rule__MigrationBlock__Group__3__Impl"
    // InternalMickeyLang.g:4584:1: rule__MigrationBlock__Group__3__Impl : ( ( rule__MigrationBlock__Group_3__0 )? ) ;
    public final void rule__MigrationBlock__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4588:1: ( ( ( rule__MigrationBlock__Group_3__0 )? ) )
            // InternalMickeyLang.g:4589:1: ( ( rule__MigrationBlock__Group_3__0 )? )
            {
            // InternalMickeyLang.g:4589:1: ( ( rule__MigrationBlock__Group_3__0 )? )
            // InternalMickeyLang.g:4590:2: ( rule__MigrationBlock__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getGroup_3()); 
            }
            // InternalMickeyLang.g:4591:2: ( rule__MigrationBlock__Group_3__0 )?
            int alt52=2;
            int LA52_0 = input.LA(1);

            if ( (LA52_0==73) ) {
                alt52=1;
            }
            switch (alt52) {
                case 1 :
                    // InternalMickeyLang.g:4591:3: rule__MigrationBlock__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__MigrationBlock__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getGroup_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__3__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__4"
    // InternalMickeyLang.g:4599:1: rule__MigrationBlock__Group__4 : rule__MigrationBlock__Group__4__Impl rule__MigrationBlock__Group__5 ;
    public final void rule__MigrationBlock__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4603:1: ( rule__MigrationBlock__Group__4__Impl rule__MigrationBlock__Group__5 )
            // InternalMickeyLang.g:4604:2: rule__MigrationBlock__Group__4__Impl rule__MigrationBlock__Group__5
            {
            pushFollow(FOLLOW_26);
            rule__MigrationBlock__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__4"


    // $ANTLR start "rule__MigrationBlock__Group__4__Impl"
    // InternalMickeyLang.g:4611:1: rule__MigrationBlock__Group__4__Impl : ( '{' ) ;
    public final void rule__MigrationBlock__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4615:1: ( ( '{' ) )
            // InternalMickeyLang.g:4616:1: ( '{' )
            {
            // InternalMickeyLang.g:4616:1: ( '{' )
            // InternalMickeyLang.g:4617:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getLeftCurlyBracketKeyword_4()); 
            }
            match(input,64,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getLeftCurlyBracketKeyword_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__4__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__5"
    // InternalMickeyLang.g:4626:1: rule__MigrationBlock__Group__5 : rule__MigrationBlock__Group__5__Impl rule__MigrationBlock__Group__6 ;
    public final void rule__MigrationBlock__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4630:1: ( rule__MigrationBlock__Group__5__Impl rule__MigrationBlock__Group__6 )
            // InternalMickeyLang.g:4631:2: rule__MigrationBlock__Group__5__Impl rule__MigrationBlock__Group__6
            {
            pushFollow(FOLLOW_26);
            rule__MigrationBlock__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__5"


    // $ANTLR start "rule__MigrationBlock__Group__5__Impl"
    // InternalMickeyLang.g:4638:1: rule__MigrationBlock__Group__5__Impl : ( ( rule__MigrationBlock__Group_5__0 )* ) ;
    public final void rule__MigrationBlock__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4642:1: ( ( ( rule__MigrationBlock__Group_5__0 )* ) )
            // InternalMickeyLang.g:4643:1: ( ( rule__MigrationBlock__Group_5__0 )* )
            {
            // InternalMickeyLang.g:4643:1: ( ( rule__MigrationBlock__Group_5__0 )* )
            // InternalMickeyLang.g:4644:2: ( rule__MigrationBlock__Group_5__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getGroup_5()); 
            }
            // InternalMickeyLang.g:4645:2: ( rule__MigrationBlock__Group_5__0 )*
            loop53:
            do {
                int alt53=2;
                int LA53_0 = input.LA(1);

                if ( (LA53_0==93||LA53_0==99||LA53_0==102) ) {
                    alt53=1;
                }


                switch (alt53) {
            	case 1 :
            	    // InternalMickeyLang.g:4645:3: rule__MigrationBlock__Group_5__0
            	    {
            	    pushFollow(FOLLOW_27);
            	    rule__MigrationBlock__Group_5__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop53;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getGroup_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__5__Impl"


    // $ANTLR start "rule__MigrationBlock__Group__6"
    // InternalMickeyLang.g:4653:1: rule__MigrationBlock__Group__6 : rule__MigrationBlock__Group__6__Impl ;
    public final void rule__MigrationBlock__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4657:1: ( rule__MigrationBlock__Group__6__Impl )
            // InternalMickeyLang.g:4658:2: rule__MigrationBlock__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__6"


    // $ANTLR start "rule__MigrationBlock__Group__6__Impl"
    // InternalMickeyLang.g:4664:1: rule__MigrationBlock__Group__6__Impl : ( '}' ) ;
    public final void rule__MigrationBlock__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4668:1: ( ( '}' ) )
            // InternalMickeyLang.g:4669:1: ( '}' )
            {
            // InternalMickeyLang.g:4669:1: ( '}' )
            // InternalMickeyLang.g:4670:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getRightCurlyBracketKeyword_6()); 
            }
            match(input,65,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getRightCurlyBracketKeyword_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group__6__Impl"


    // $ANTLR start "rule__MigrationBlock__Group_3__0"
    // InternalMickeyLang.g:4680:1: rule__MigrationBlock__Group_3__0 : rule__MigrationBlock__Group_3__0__Impl rule__MigrationBlock__Group_3__1 ;
    public final void rule__MigrationBlock__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4684:1: ( rule__MigrationBlock__Group_3__0__Impl rule__MigrationBlock__Group_3__1 )
            // InternalMickeyLang.g:4685:2: rule__MigrationBlock__Group_3__0__Impl rule__MigrationBlock__Group_3__1
            {
            pushFollow(FOLLOW_3);
            rule__MigrationBlock__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_3__0"


    // $ANTLR start "rule__MigrationBlock__Group_3__0__Impl"
    // InternalMickeyLang.g:4692:1: rule__MigrationBlock__Group_3__0__Impl : ( 'from' ) ;
    public final void rule__MigrationBlock__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4696:1: ( ( 'from' ) )
            // InternalMickeyLang.g:4697:1: ( 'from' )
            {
            // InternalMickeyLang.g:4697:1: ( 'from' )
            // InternalMickeyLang.g:4698:2: 'from'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getFromKeyword_3_0()); 
            }
            match(input,73,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getFromKeyword_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_3__0__Impl"


    // $ANTLR start "rule__MigrationBlock__Group_3__1"
    // InternalMickeyLang.g:4707:1: rule__MigrationBlock__Group_3__1 : rule__MigrationBlock__Group_3__1__Impl ;
    public final void rule__MigrationBlock__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4711:1: ( rule__MigrationBlock__Group_3__1__Impl )
            // InternalMickeyLang.g:4712:2: rule__MigrationBlock__Group_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_3__1"


    // $ANTLR start "rule__MigrationBlock__Group_3__1__Impl"
    // InternalMickeyLang.g:4718:1: rule__MigrationBlock__Group_3__1__Impl : ( ( rule__MigrationBlock__FromAssignment_3_1 ) ) ;
    public final void rule__MigrationBlock__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4722:1: ( ( ( rule__MigrationBlock__FromAssignment_3_1 ) ) )
            // InternalMickeyLang.g:4723:1: ( ( rule__MigrationBlock__FromAssignment_3_1 ) )
            {
            // InternalMickeyLang.g:4723:1: ( ( rule__MigrationBlock__FromAssignment_3_1 ) )
            // InternalMickeyLang.g:4724:2: ( rule__MigrationBlock__FromAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getFromAssignment_3_1()); 
            }
            // InternalMickeyLang.g:4725:2: ( rule__MigrationBlock__FromAssignment_3_1 )
            // InternalMickeyLang.g:4725:3: rule__MigrationBlock__FromAssignment_3_1
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__FromAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getFromAssignment_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_3__1__Impl"


    // $ANTLR start "rule__MigrationBlock__Group_5__0"
    // InternalMickeyLang.g:4734:1: rule__MigrationBlock__Group_5__0 : rule__MigrationBlock__Group_5__0__Impl rule__MigrationBlock__Group_5__1 ;
    public final void rule__MigrationBlock__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4738:1: ( rule__MigrationBlock__Group_5__0__Impl rule__MigrationBlock__Group_5__1 )
            // InternalMickeyLang.g:4739:2: rule__MigrationBlock__Group_5__0__Impl rule__MigrationBlock__Group_5__1
            {
            pushFollow(FOLLOW_14);
            rule__MigrationBlock__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_5__0"


    // $ANTLR start "rule__MigrationBlock__Group_5__0__Impl"
    // InternalMickeyLang.g:4746:1: rule__MigrationBlock__Group_5__0__Impl : ( ( rule__MigrationBlock__StatementsAssignment_5_0 ) ) ;
    public final void rule__MigrationBlock__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4750:1: ( ( ( rule__MigrationBlock__StatementsAssignment_5_0 ) ) )
            // InternalMickeyLang.g:4751:1: ( ( rule__MigrationBlock__StatementsAssignment_5_0 ) )
            {
            // InternalMickeyLang.g:4751:1: ( ( rule__MigrationBlock__StatementsAssignment_5_0 ) )
            // InternalMickeyLang.g:4752:2: ( rule__MigrationBlock__StatementsAssignment_5_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getStatementsAssignment_5_0()); 
            }
            // InternalMickeyLang.g:4753:2: ( rule__MigrationBlock__StatementsAssignment_5_0 )
            // InternalMickeyLang.g:4753:3: rule__MigrationBlock__StatementsAssignment_5_0
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__StatementsAssignment_5_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getStatementsAssignment_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_5__0__Impl"


    // $ANTLR start "rule__MigrationBlock__Group_5__1"
    // InternalMickeyLang.g:4761:1: rule__MigrationBlock__Group_5__1 : rule__MigrationBlock__Group_5__1__Impl ;
    public final void rule__MigrationBlock__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4765:1: ( rule__MigrationBlock__Group_5__1__Impl )
            // InternalMickeyLang.g:4766:2: rule__MigrationBlock__Group_5__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MigrationBlock__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_5__1"


    // $ANTLR start "rule__MigrationBlock__Group_5__1__Impl"
    // InternalMickeyLang.g:4772:1: rule__MigrationBlock__Group_5__1__Impl : ( ';' ) ;
    public final void rule__MigrationBlock__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4776:1: ( ( ';' ) )
            // InternalMickeyLang.g:4777:1: ( ';' )
            {
            // InternalMickeyLang.g:4777:1: ( ';' )
            // InternalMickeyLang.g:4778:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getSemicolonKeyword_5_1()); 
            }
            match(input,67,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getSemicolonKeyword_5_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__Group_5__1__Impl"


    // $ANTLR start "rule__ExprConcat__Group__0"
    // InternalMickeyLang.g:4788:1: rule__ExprConcat__Group__0 : rule__ExprConcat__Group__0__Impl rule__ExprConcat__Group__1 ;
    public final void rule__ExprConcat__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4792:1: ( rule__ExprConcat__Group__0__Impl rule__ExprConcat__Group__1 )
            // InternalMickeyLang.g:4793:2: rule__ExprConcat__Group__0__Impl rule__ExprConcat__Group__1
            {
            pushFollow(FOLLOW_28);
            rule__ExprConcat__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprConcat__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group__0"


    // $ANTLR start "rule__ExprConcat__Group__0__Impl"
    // InternalMickeyLang.g:4800:1: rule__ExprConcat__Group__0__Impl : ( ruleExprMult ) ;
    public final void rule__ExprConcat__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4804:1: ( ( ruleExprMult ) )
            // InternalMickeyLang.g:4805:1: ( ruleExprMult )
            {
            // InternalMickeyLang.g:4805:1: ( ruleExprMult )
            // InternalMickeyLang.g:4806:2: ruleExprMult
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getExprMultParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprMult();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getExprMultParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group__0__Impl"


    // $ANTLR start "rule__ExprConcat__Group__1"
    // InternalMickeyLang.g:4815:1: rule__ExprConcat__Group__1 : rule__ExprConcat__Group__1__Impl ;
    public final void rule__ExprConcat__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4819:1: ( rule__ExprConcat__Group__1__Impl )
            // InternalMickeyLang.g:4820:2: rule__ExprConcat__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprConcat__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group__1"


    // $ANTLR start "rule__ExprConcat__Group__1__Impl"
    // InternalMickeyLang.g:4826:1: rule__ExprConcat__Group__1__Impl : ( ( rule__ExprConcat__Group_1__0 )* ) ;
    public final void rule__ExprConcat__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4830:1: ( ( ( rule__ExprConcat__Group_1__0 )* ) )
            // InternalMickeyLang.g:4831:1: ( ( rule__ExprConcat__Group_1__0 )* )
            {
            // InternalMickeyLang.g:4831:1: ( ( rule__ExprConcat__Group_1__0 )* )
            // InternalMickeyLang.g:4832:2: ( rule__ExprConcat__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:4833:2: ( rule__ExprConcat__Group_1__0 )*
            loop54:
            do {
                int alt54=2;
                int LA54_0 = input.LA(1);

                if ( (LA54_0==118) ) {
                    alt54=1;
                }


                switch (alt54) {
            	case 1 :
            	    // InternalMickeyLang.g:4833:3: rule__ExprConcat__Group_1__0
            	    {
            	    pushFollow(FOLLOW_29);
            	    rule__ExprConcat__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop54;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group__1__Impl"


    // $ANTLR start "rule__ExprConcat__Group_1__0"
    // InternalMickeyLang.g:4842:1: rule__ExprConcat__Group_1__0 : rule__ExprConcat__Group_1__0__Impl rule__ExprConcat__Group_1__1 ;
    public final void rule__ExprConcat__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4846:1: ( rule__ExprConcat__Group_1__0__Impl rule__ExprConcat__Group_1__1 )
            // InternalMickeyLang.g:4847:2: rule__ExprConcat__Group_1__0__Impl rule__ExprConcat__Group_1__1
            {
            pushFollow(FOLLOW_28);
            rule__ExprConcat__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprConcat__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group_1__0"


    // $ANTLR start "rule__ExprConcat__Group_1__0__Impl"
    // InternalMickeyLang.g:4854:1: rule__ExprConcat__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprConcat__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4858:1: ( ( () ) )
            // InternalMickeyLang.g:4859:1: ( () )
            {
            // InternalMickeyLang.g:4859:1: ( () )
            // InternalMickeyLang.g:4860:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getExprConcatLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:4861:2: ()
            // InternalMickeyLang.g:4861:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getExprConcatLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group_1__0__Impl"


    // $ANTLR start "rule__ExprConcat__Group_1__1"
    // InternalMickeyLang.g:4869:1: rule__ExprConcat__Group_1__1 : rule__ExprConcat__Group_1__1__Impl rule__ExprConcat__Group_1__2 ;
    public final void rule__ExprConcat__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4873:1: ( rule__ExprConcat__Group_1__1__Impl rule__ExprConcat__Group_1__2 )
            // InternalMickeyLang.g:4874:2: rule__ExprConcat__Group_1__1__Impl rule__ExprConcat__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprConcat__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprConcat__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group_1__1"


    // $ANTLR start "rule__ExprConcat__Group_1__1__Impl"
    // InternalMickeyLang.g:4881:1: rule__ExprConcat__Group_1__1__Impl : ( ( rule__ExprConcat__OpAssignment_1_1 ) ) ;
    public final void rule__ExprConcat__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4885:1: ( ( ( rule__ExprConcat__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:4886:1: ( ( rule__ExprConcat__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:4886:1: ( ( rule__ExprConcat__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:4887:2: ( rule__ExprConcat__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:4888:2: ( rule__ExprConcat__OpAssignment_1_1 )
            // InternalMickeyLang.g:4888:3: rule__ExprConcat__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprConcat__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group_1__1__Impl"


    // $ANTLR start "rule__ExprConcat__Group_1__2"
    // InternalMickeyLang.g:4896:1: rule__ExprConcat__Group_1__2 : rule__ExprConcat__Group_1__2__Impl ;
    public final void rule__ExprConcat__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4900:1: ( rule__ExprConcat__Group_1__2__Impl )
            // InternalMickeyLang.g:4901:2: rule__ExprConcat__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprConcat__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group_1__2"


    // $ANTLR start "rule__ExprConcat__Group_1__2__Impl"
    // InternalMickeyLang.g:4907:1: rule__ExprConcat__Group_1__2__Impl : ( ( rule__ExprConcat__RightAssignment_1_2 ) ) ;
    public final void rule__ExprConcat__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4911:1: ( ( ( rule__ExprConcat__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:4912:1: ( ( rule__ExprConcat__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:4912:1: ( ( rule__ExprConcat__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:4913:2: ( rule__ExprConcat__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:4914:2: ( rule__ExprConcat__RightAssignment_1_2 )
            // InternalMickeyLang.g:4914:3: rule__ExprConcat__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprConcat__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__Group_1__2__Impl"


    // $ANTLR start "rule__ExprMult__Group__0"
    // InternalMickeyLang.g:4923:1: rule__ExprMult__Group__0 : rule__ExprMult__Group__0__Impl rule__ExprMult__Group__1 ;
    public final void rule__ExprMult__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4927:1: ( rule__ExprMult__Group__0__Impl rule__ExprMult__Group__1 )
            // InternalMickeyLang.g:4928:2: rule__ExprMult__Group__0__Impl rule__ExprMult__Group__1
            {
            pushFollow(FOLLOW_31);
            rule__ExprMult__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprMult__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group__0"


    // $ANTLR start "rule__ExprMult__Group__0__Impl"
    // InternalMickeyLang.g:4935:1: rule__ExprMult__Group__0__Impl : ( ruleExprAdd ) ;
    public final void rule__ExprMult__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4939:1: ( ( ruleExprAdd ) )
            // InternalMickeyLang.g:4940:1: ( ruleExprAdd )
            {
            // InternalMickeyLang.g:4940:1: ( ruleExprAdd )
            // InternalMickeyLang.g:4941:2: ruleExprAdd
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getExprAddParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprAdd();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getExprAddParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group__0__Impl"


    // $ANTLR start "rule__ExprMult__Group__1"
    // InternalMickeyLang.g:4950:1: rule__ExprMult__Group__1 : rule__ExprMult__Group__1__Impl ;
    public final void rule__ExprMult__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4954:1: ( rule__ExprMult__Group__1__Impl )
            // InternalMickeyLang.g:4955:2: rule__ExprMult__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprMult__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group__1"


    // $ANTLR start "rule__ExprMult__Group__1__Impl"
    // InternalMickeyLang.g:4961:1: rule__ExprMult__Group__1__Impl : ( ( rule__ExprMult__Group_1__0 )* ) ;
    public final void rule__ExprMult__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4965:1: ( ( ( rule__ExprMult__Group_1__0 )* ) )
            // InternalMickeyLang.g:4966:1: ( ( rule__ExprMult__Group_1__0 )* )
            {
            // InternalMickeyLang.g:4966:1: ( ( rule__ExprMult__Group_1__0 )* )
            // InternalMickeyLang.g:4967:2: ( rule__ExprMult__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:4968:2: ( rule__ExprMult__Group_1__0 )*
            loop55:
            do {
                int alt55=2;
                int LA55_0 = input.LA(1);

                if ( ((LA55_0>=12 && LA55_0<=14)) ) {
                    alt55=1;
                }


                switch (alt55) {
            	case 1 :
            	    // InternalMickeyLang.g:4968:3: rule__ExprMult__Group_1__0
            	    {
            	    pushFollow(FOLLOW_32);
            	    rule__ExprMult__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop55;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group__1__Impl"


    // $ANTLR start "rule__ExprMult__Group_1__0"
    // InternalMickeyLang.g:4977:1: rule__ExprMult__Group_1__0 : rule__ExprMult__Group_1__0__Impl rule__ExprMult__Group_1__1 ;
    public final void rule__ExprMult__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4981:1: ( rule__ExprMult__Group_1__0__Impl rule__ExprMult__Group_1__1 )
            // InternalMickeyLang.g:4982:2: rule__ExprMult__Group_1__0__Impl rule__ExprMult__Group_1__1
            {
            pushFollow(FOLLOW_31);
            rule__ExprMult__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprMult__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group_1__0"


    // $ANTLR start "rule__ExprMult__Group_1__0__Impl"
    // InternalMickeyLang.g:4989:1: rule__ExprMult__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprMult__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:4993:1: ( ( () ) )
            // InternalMickeyLang.g:4994:1: ( () )
            {
            // InternalMickeyLang.g:4994:1: ( () )
            // InternalMickeyLang.g:4995:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getExprMultLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:4996:2: ()
            // InternalMickeyLang.g:4996:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getExprMultLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group_1__0__Impl"


    // $ANTLR start "rule__ExprMult__Group_1__1"
    // InternalMickeyLang.g:5004:1: rule__ExprMult__Group_1__1 : rule__ExprMult__Group_1__1__Impl rule__ExprMult__Group_1__2 ;
    public final void rule__ExprMult__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5008:1: ( rule__ExprMult__Group_1__1__Impl rule__ExprMult__Group_1__2 )
            // InternalMickeyLang.g:5009:2: rule__ExprMult__Group_1__1__Impl rule__ExprMult__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprMult__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprMult__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group_1__1"


    // $ANTLR start "rule__ExprMult__Group_1__1__Impl"
    // InternalMickeyLang.g:5016:1: rule__ExprMult__Group_1__1__Impl : ( ( rule__ExprMult__OpAssignment_1_1 ) ) ;
    public final void rule__ExprMult__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5020:1: ( ( ( rule__ExprMult__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5021:1: ( ( rule__ExprMult__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5021:1: ( ( rule__ExprMult__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5022:2: ( rule__ExprMult__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5023:2: ( rule__ExprMult__OpAssignment_1_1 )
            // InternalMickeyLang.g:5023:3: rule__ExprMult__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprMult__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group_1__1__Impl"


    // $ANTLR start "rule__ExprMult__Group_1__2"
    // InternalMickeyLang.g:5031:1: rule__ExprMult__Group_1__2 : rule__ExprMult__Group_1__2__Impl ;
    public final void rule__ExprMult__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5035:1: ( rule__ExprMult__Group_1__2__Impl )
            // InternalMickeyLang.g:5036:2: rule__ExprMult__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprMult__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group_1__2"


    // $ANTLR start "rule__ExprMult__Group_1__2__Impl"
    // InternalMickeyLang.g:5042:1: rule__ExprMult__Group_1__2__Impl : ( ( rule__ExprMult__RightAssignment_1_2 ) ) ;
    public final void rule__ExprMult__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5046:1: ( ( ( rule__ExprMult__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5047:1: ( ( rule__ExprMult__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5047:1: ( ( rule__ExprMult__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5048:2: ( rule__ExprMult__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5049:2: ( rule__ExprMult__RightAssignment_1_2 )
            // InternalMickeyLang.g:5049:3: rule__ExprMult__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprMult__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__Group_1__2__Impl"


    // $ANTLR start "rule__ExprAdd__Group__0"
    // InternalMickeyLang.g:5058:1: rule__ExprAdd__Group__0 : rule__ExprAdd__Group__0__Impl rule__ExprAdd__Group__1 ;
    public final void rule__ExprAdd__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5062:1: ( rule__ExprAdd__Group__0__Impl rule__ExprAdd__Group__1 )
            // InternalMickeyLang.g:5063:2: rule__ExprAdd__Group__0__Impl rule__ExprAdd__Group__1
            {
            pushFollow(FOLLOW_33);
            rule__ExprAdd__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprAdd__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group__0"


    // $ANTLR start "rule__ExprAdd__Group__0__Impl"
    // InternalMickeyLang.g:5070:1: rule__ExprAdd__Group__0__Impl : ( ruleExprBit ) ;
    public final void rule__ExprAdd__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5074:1: ( ( ruleExprBit ) )
            // InternalMickeyLang.g:5075:1: ( ruleExprBit )
            {
            // InternalMickeyLang.g:5075:1: ( ruleExprBit )
            // InternalMickeyLang.g:5076:2: ruleExprBit
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getExprBitParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprBit();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getExprBitParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group__0__Impl"


    // $ANTLR start "rule__ExprAdd__Group__1"
    // InternalMickeyLang.g:5085:1: rule__ExprAdd__Group__1 : rule__ExprAdd__Group__1__Impl ;
    public final void rule__ExprAdd__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5089:1: ( rule__ExprAdd__Group__1__Impl )
            // InternalMickeyLang.g:5090:2: rule__ExprAdd__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprAdd__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group__1"


    // $ANTLR start "rule__ExprAdd__Group__1__Impl"
    // InternalMickeyLang.g:5096:1: rule__ExprAdd__Group__1__Impl : ( ( rule__ExprAdd__Group_1__0 )* ) ;
    public final void rule__ExprAdd__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5100:1: ( ( ( rule__ExprAdd__Group_1__0 )* ) )
            // InternalMickeyLang.g:5101:1: ( ( rule__ExprAdd__Group_1__0 )* )
            {
            // InternalMickeyLang.g:5101:1: ( ( rule__ExprAdd__Group_1__0 )* )
            // InternalMickeyLang.g:5102:2: ( rule__ExprAdd__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5103:2: ( rule__ExprAdd__Group_1__0 )*
            loop56:
            do {
                int alt56=2;
                int LA56_0 = input.LA(1);

                if ( ((LA56_0>=15 && LA56_0<=16)) ) {
                    alt56=1;
                }


                switch (alt56) {
            	case 1 :
            	    // InternalMickeyLang.g:5103:3: rule__ExprAdd__Group_1__0
            	    {
            	    pushFollow(FOLLOW_34);
            	    rule__ExprAdd__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop56;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group__1__Impl"


    // $ANTLR start "rule__ExprAdd__Group_1__0"
    // InternalMickeyLang.g:5112:1: rule__ExprAdd__Group_1__0 : rule__ExprAdd__Group_1__0__Impl rule__ExprAdd__Group_1__1 ;
    public final void rule__ExprAdd__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5116:1: ( rule__ExprAdd__Group_1__0__Impl rule__ExprAdd__Group_1__1 )
            // InternalMickeyLang.g:5117:2: rule__ExprAdd__Group_1__0__Impl rule__ExprAdd__Group_1__1
            {
            pushFollow(FOLLOW_33);
            rule__ExprAdd__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprAdd__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group_1__0"


    // $ANTLR start "rule__ExprAdd__Group_1__0__Impl"
    // InternalMickeyLang.g:5124:1: rule__ExprAdd__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprAdd__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5128:1: ( ( () ) )
            // InternalMickeyLang.g:5129:1: ( () )
            {
            // InternalMickeyLang.g:5129:1: ( () )
            // InternalMickeyLang.g:5130:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getExprAddLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5131:2: ()
            // InternalMickeyLang.g:5131:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getExprAddLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group_1__0__Impl"


    // $ANTLR start "rule__ExprAdd__Group_1__1"
    // InternalMickeyLang.g:5139:1: rule__ExprAdd__Group_1__1 : rule__ExprAdd__Group_1__1__Impl rule__ExprAdd__Group_1__2 ;
    public final void rule__ExprAdd__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5143:1: ( rule__ExprAdd__Group_1__1__Impl rule__ExprAdd__Group_1__2 )
            // InternalMickeyLang.g:5144:2: rule__ExprAdd__Group_1__1__Impl rule__ExprAdd__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprAdd__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprAdd__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group_1__1"


    // $ANTLR start "rule__ExprAdd__Group_1__1__Impl"
    // InternalMickeyLang.g:5151:1: rule__ExprAdd__Group_1__1__Impl : ( ( rule__ExprAdd__OpAssignment_1_1 ) ) ;
    public final void rule__ExprAdd__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5155:1: ( ( ( rule__ExprAdd__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5156:1: ( ( rule__ExprAdd__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5156:1: ( ( rule__ExprAdd__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5157:2: ( rule__ExprAdd__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5158:2: ( rule__ExprAdd__OpAssignment_1_1 )
            // InternalMickeyLang.g:5158:3: rule__ExprAdd__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprAdd__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group_1__1__Impl"


    // $ANTLR start "rule__ExprAdd__Group_1__2"
    // InternalMickeyLang.g:5166:1: rule__ExprAdd__Group_1__2 : rule__ExprAdd__Group_1__2__Impl ;
    public final void rule__ExprAdd__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5170:1: ( rule__ExprAdd__Group_1__2__Impl )
            // InternalMickeyLang.g:5171:2: rule__ExprAdd__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprAdd__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group_1__2"


    // $ANTLR start "rule__ExprAdd__Group_1__2__Impl"
    // InternalMickeyLang.g:5177:1: rule__ExprAdd__Group_1__2__Impl : ( ( rule__ExprAdd__RightAssignment_1_2 ) ) ;
    public final void rule__ExprAdd__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5181:1: ( ( ( rule__ExprAdd__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5182:1: ( ( rule__ExprAdd__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5182:1: ( ( rule__ExprAdd__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5183:2: ( rule__ExprAdd__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5184:2: ( rule__ExprAdd__RightAssignment_1_2 )
            // InternalMickeyLang.g:5184:3: rule__ExprAdd__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprAdd__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__Group_1__2__Impl"


    // $ANTLR start "rule__ExprBit__Group__0"
    // InternalMickeyLang.g:5193:1: rule__ExprBit__Group__0 : rule__ExprBit__Group__0__Impl rule__ExprBit__Group__1 ;
    public final void rule__ExprBit__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5197:1: ( rule__ExprBit__Group__0__Impl rule__ExprBit__Group__1 )
            // InternalMickeyLang.g:5198:2: rule__ExprBit__Group__0__Impl rule__ExprBit__Group__1
            {
            pushFollow(FOLLOW_35);
            rule__ExprBit__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprBit__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group__0"


    // $ANTLR start "rule__ExprBit__Group__0__Impl"
    // InternalMickeyLang.g:5205:1: rule__ExprBit__Group__0__Impl : ( ruleExprRelate ) ;
    public final void rule__ExprBit__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5209:1: ( ( ruleExprRelate ) )
            // InternalMickeyLang.g:5210:1: ( ruleExprRelate )
            {
            // InternalMickeyLang.g:5210:1: ( ruleExprRelate )
            // InternalMickeyLang.g:5211:2: ruleExprRelate
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getExprRelateParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprRelate();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getExprRelateParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group__0__Impl"


    // $ANTLR start "rule__ExprBit__Group__1"
    // InternalMickeyLang.g:5220:1: rule__ExprBit__Group__1 : rule__ExprBit__Group__1__Impl ;
    public final void rule__ExprBit__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5224:1: ( rule__ExprBit__Group__1__Impl )
            // InternalMickeyLang.g:5225:2: rule__ExprBit__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprBit__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group__1"


    // $ANTLR start "rule__ExprBit__Group__1__Impl"
    // InternalMickeyLang.g:5231:1: rule__ExprBit__Group__1__Impl : ( ( rule__ExprBit__Group_1__0 )* ) ;
    public final void rule__ExprBit__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5235:1: ( ( ( rule__ExprBit__Group_1__0 )* ) )
            // InternalMickeyLang.g:5236:1: ( ( rule__ExprBit__Group_1__0 )* )
            {
            // InternalMickeyLang.g:5236:1: ( ( rule__ExprBit__Group_1__0 )* )
            // InternalMickeyLang.g:5237:2: ( rule__ExprBit__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5238:2: ( rule__ExprBit__Group_1__0 )*
            loop57:
            do {
                int alt57=2;
                int LA57_0 = input.LA(1);

                if ( ((LA57_0>=17 && LA57_0<=20)) ) {
                    alt57=1;
                }


                switch (alt57) {
            	case 1 :
            	    // InternalMickeyLang.g:5238:3: rule__ExprBit__Group_1__0
            	    {
            	    pushFollow(FOLLOW_36);
            	    rule__ExprBit__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop57;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group__1__Impl"


    // $ANTLR start "rule__ExprBit__Group_1__0"
    // InternalMickeyLang.g:5247:1: rule__ExprBit__Group_1__0 : rule__ExprBit__Group_1__0__Impl rule__ExprBit__Group_1__1 ;
    public final void rule__ExprBit__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5251:1: ( rule__ExprBit__Group_1__0__Impl rule__ExprBit__Group_1__1 )
            // InternalMickeyLang.g:5252:2: rule__ExprBit__Group_1__0__Impl rule__ExprBit__Group_1__1
            {
            pushFollow(FOLLOW_35);
            rule__ExprBit__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprBit__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group_1__0"


    // $ANTLR start "rule__ExprBit__Group_1__0__Impl"
    // InternalMickeyLang.g:5259:1: rule__ExprBit__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprBit__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5263:1: ( ( () ) )
            // InternalMickeyLang.g:5264:1: ( () )
            {
            // InternalMickeyLang.g:5264:1: ( () )
            // InternalMickeyLang.g:5265:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getExprBitLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5266:2: ()
            // InternalMickeyLang.g:5266:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getExprBitLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group_1__0__Impl"


    // $ANTLR start "rule__ExprBit__Group_1__1"
    // InternalMickeyLang.g:5274:1: rule__ExprBit__Group_1__1 : rule__ExprBit__Group_1__1__Impl rule__ExprBit__Group_1__2 ;
    public final void rule__ExprBit__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5278:1: ( rule__ExprBit__Group_1__1__Impl rule__ExprBit__Group_1__2 )
            // InternalMickeyLang.g:5279:2: rule__ExprBit__Group_1__1__Impl rule__ExprBit__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprBit__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprBit__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group_1__1"


    // $ANTLR start "rule__ExprBit__Group_1__1__Impl"
    // InternalMickeyLang.g:5286:1: rule__ExprBit__Group_1__1__Impl : ( ( rule__ExprBit__OpAssignment_1_1 ) ) ;
    public final void rule__ExprBit__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5290:1: ( ( ( rule__ExprBit__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5291:1: ( ( rule__ExprBit__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5291:1: ( ( rule__ExprBit__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5292:2: ( rule__ExprBit__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5293:2: ( rule__ExprBit__OpAssignment_1_1 )
            // InternalMickeyLang.g:5293:3: rule__ExprBit__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprBit__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group_1__1__Impl"


    // $ANTLR start "rule__ExprBit__Group_1__2"
    // InternalMickeyLang.g:5301:1: rule__ExprBit__Group_1__2 : rule__ExprBit__Group_1__2__Impl ;
    public final void rule__ExprBit__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5305:1: ( rule__ExprBit__Group_1__2__Impl )
            // InternalMickeyLang.g:5306:2: rule__ExprBit__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprBit__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group_1__2"


    // $ANTLR start "rule__ExprBit__Group_1__2__Impl"
    // InternalMickeyLang.g:5312:1: rule__ExprBit__Group_1__2__Impl : ( ( rule__ExprBit__RightAssignment_1_2 ) ) ;
    public final void rule__ExprBit__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5316:1: ( ( ( rule__ExprBit__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5317:1: ( ( rule__ExprBit__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5317:1: ( ( rule__ExprBit__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5318:2: ( rule__ExprBit__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5319:2: ( rule__ExprBit__RightAssignment_1_2 )
            // InternalMickeyLang.g:5319:3: rule__ExprBit__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprBit__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__Group_1__2__Impl"


    // $ANTLR start "rule__ExprRelate__Group__0"
    // InternalMickeyLang.g:5328:1: rule__ExprRelate__Group__0 : rule__ExprRelate__Group__0__Impl rule__ExprRelate__Group__1 ;
    public final void rule__ExprRelate__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5332:1: ( rule__ExprRelate__Group__0__Impl rule__ExprRelate__Group__1 )
            // InternalMickeyLang.g:5333:2: rule__ExprRelate__Group__0__Impl rule__ExprRelate__Group__1
            {
            pushFollow(FOLLOW_37);
            rule__ExprRelate__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprRelate__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group__0"


    // $ANTLR start "rule__ExprRelate__Group__0__Impl"
    // InternalMickeyLang.g:5340:1: rule__ExprRelate__Group__0__Impl : ( ruleExprEqual ) ;
    public final void rule__ExprRelate__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5344:1: ( ( ruleExprEqual ) )
            // InternalMickeyLang.g:5345:1: ( ruleExprEqual )
            {
            // InternalMickeyLang.g:5345:1: ( ruleExprEqual )
            // InternalMickeyLang.g:5346:2: ruleExprEqual
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getExprEqualParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprEqual();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getExprEqualParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group__0__Impl"


    // $ANTLR start "rule__ExprRelate__Group__1"
    // InternalMickeyLang.g:5355:1: rule__ExprRelate__Group__1 : rule__ExprRelate__Group__1__Impl ;
    public final void rule__ExprRelate__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5359:1: ( rule__ExprRelate__Group__1__Impl )
            // InternalMickeyLang.g:5360:2: rule__ExprRelate__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprRelate__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group__1"


    // $ANTLR start "rule__ExprRelate__Group__1__Impl"
    // InternalMickeyLang.g:5366:1: rule__ExprRelate__Group__1__Impl : ( ( rule__ExprRelate__Group_1__0 )* ) ;
    public final void rule__ExprRelate__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5370:1: ( ( ( rule__ExprRelate__Group_1__0 )* ) )
            // InternalMickeyLang.g:5371:1: ( ( rule__ExprRelate__Group_1__0 )* )
            {
            // InternalMickeyLang.g:5371:1: ( ( rule__ExprRelate__Group_1__0 )* )
            // InternalMickeyLang.g:5372:2: ( rule__ExprRelate__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5373:2: ( rule__ExprRelate__Group_1__0 )*
            loop58:
            do {
                int alt58=2;
                int LA58_0 = input.LA(1);

                if ( ((LA58_0>=21 && LA58_0<=24)) ) {
                    alt58=1;
                }


                switch (alt58) {
            	case 1 :
            	    // InternalMickeyLang.g:5373:3: rule__ExprRelate__Group_1__0
            	    {
            	    pushFollow(FOLLOW_38);
            	    rule__ExprRelate__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop58;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group__1__Impl"


    // $ANTLR start "rule__ExprRelate__Group_1__0"
    // InternalMickeyLang.g:5382:1: rule__ExprRelate__Group_1__0 : rule__ExprRelate__Group_1__0__Impl rule__ExprRelate__Group_1__1 ;
    public final void rule__ExprRelate__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5386:1: ( rule__ExprRelate__Group_1__0__Impl rule__ExprRelate__Group_1__1 )
            // InternalMickeyLang.g:5387:2: rule__ExprRelate__Group_1__0__Impl rule__ExprRelate__Group_1__1
            {
            pushFollow(FOLLOW_37);
            rule__ExprRelate__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprRelate__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group_1__0"


    // $ANTLR start "rule__ExprRelate__Group_1__0__Impl"
    // InternalMickeyLang.g:5394:1: rule__ExprRelate__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprRelate__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5398:1: ( ( () ) )
            // InternalMickeyLang.g:5399:1: ( () )
            {
            // InternalMickeyLang.g:5399:1: ( () )
            // InternalMickeyLang.g:5400:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getExprRelateLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5401:2: ()
            // InternalMickeyLang.g:5401:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getExprRelateLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group_1__0__Impl"


    // $ANTLR start "rule__ExprRelate__Group_1__1"
    // InternalMickeyLang.g:5409:1: rule__ExprRelate__Group_1__1 : rule__ExprRelate__Group_1__1__Impl rule__ExprRelate__Group_1__2 ;
    public final void rule__ExprRelate__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5413:1: ( rule__ExprRelate__Group_1__1__Impl rule__ExprRelate__Group_1__2 )
            // InternalMickeyLang.g:5414:2: rule__ExprRelate__Group_1__1__Impl rule__ExprRelate__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprRelate__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprRelate__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group_1__1"


    // $ANTLR start "rule__ExprRelate__Group_1__1__Impl"
    // InternalMickeyLang.g:5421:1: rule__ExprRelate__Group_1__1__Impl : ( ( rule__ExprRelate__OpAssignment_1_1 ) ) ;
    public final void rule__ExprRelate__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5425:1: ( ( ( rule__ExprRelate__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5426:1: ( ( rule__ExprRelate__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5426:1: ( ( rule__ExprRelate__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5427:2: ( rule__ExprRelate__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5428:2: ( rule__ExprRelate__OpAssignment_1_1 )
            // InternalMickeyLang.g:5428:3: rule__ExprRelate__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprRelate__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group_1__1__Impl"


    // $ANTLR start "rule__ExprRelate__Group_1__2"
    // InternalMickeyLang.g:5436:1: rule__ExprRelate__Group_1__2 : rule__ExprRelate__Group_1__2__Impl ;
    public final void rule__ExprRelate__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5440:1: ( rule__ExprRelate__Group_1__2__Impl )
            // InternalMickeyLang.g:5441:2: rule__ExprRelate__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprRelate__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group_1__2"


    // $ANTLR start "rule__ExprRelate__Group_1__2__Impl"
    // InternalMickeyLang.g:5447:1: rule__ExprRelate__Group_1__2__Impl : ( ( rule__ExprRelate__RightAssignment_1_2 ) ) ;
    public final void rule__ExprRelate__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5451:1: ( ( ( rule__ExprRelate__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5452:1: ( ( rule__ExprRelate__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5452:1: ( ( rule__ExprRelate__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5453:2: ( rule__ExprRelate__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5454:2: ( rule__ExprRelate__RightAssignment_1_2 )
            // InternalMickeyLang.g:5454:3: rule__ExprRelate__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprRelate__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__Group_1__2__Impl"


    // $ANTLR start "rule__ExprEqual__Group__0"
    // InternalMickeyLang.g:5463:1: rule__ExprEqual__Group__0 : rule__ExprEqual__Group__0__Impl rule__ExprEqual__Group__1 ;
    public final void rule__ExprEqual__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5467:1: ( rule__ExprEqual__Group__0__Impl rule__ExprEqual__Group__1 )
            // InternalMickeyLang.g:5468:2: rule__ExprEqual__Group__0__Impl rule__ExprEqual__Group__1
            {
            pushFollow(FOLLOW_39);
            rule__ExprEqual__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprEqual__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group__0"


    // $ANTLR start "rule__ExprEqual__Group__0__Impl"
    // InternalMickeyLang.g:5475:1: rule__ExprEqual__Group__0__Impl : ( ruleExprAnd ) ;
    public final void rule__ExprEqual__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5479:1: ( ( ruleExprAnd ) )
            // InternalMickeyLang.g:5480:1: ( ruleExprAnd )
            {
            // InternalMickeyLang.g:5480:1: ( ruleExprAnd )
            // InternalMickeyLang.g:5481:2: ruleExprAnd
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getExprAndParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprAnd();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getExprAndParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group__0__Impl"


    // $ANTLR start "rule__ExprEqual__Group__1"
    // InternalMickeyLang.g:5490:1: rule__ExprEqual__Group__1 : rule__ExprEqual__Group__1__Impl ;
    public final void rule__ExprEqual__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5494:1: ( rule__ExprEqual__Group__1__Impl )
            // InternalMickeyLang.g:5495:2: rule__ExprEqual__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprEqual__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group__1"


    // $ANTLR start "rule__ExprEqual__Group__1__Impl"
    // InternalMickeyLang.g:5501:1: rule__ExprEqual__Group__1__Impl : ( ( rule__ExprEqual__Group_1__0 )* ) ;
    public final void rule__ExprEqual__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5505:1: ( ( ( rule__ExprEqual__Group_1__0 )* ) )
            // InternalMickeyLang.g:5506:1: ( ( rule__ExprEqual__Group_1__0 )* )
            {
            // InternalMickeyLang.g:5506:1: ( ( rule__ExprEqual__Group_1__0 )* )
            // InternalMickeyLang.g:5507:2: ( rule__ExprEqual__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5508:2: ( rule__ExprEqual__Group_1__0 )*
            loop59:
            do {
                int alt59=2;
                int LA59_0 = input.LA(1);

                if ( ((LA59_0>=25 && LA59_0<=36)) ) {
                    alt59=1;
                }


                switch (alt59) {
            	case 1 :
            	    // InternalMickeyLang.g:5508:3: rule__ExprEqual__Group_1__0
            	    {
            	    pushFollow(FOLLOW_40);
            	    rule__ExprEqual__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop59;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group__1__Impl"


    // $ANTLR start "rule__ExprEqual__Group_1__0"
    // InternalMickeyLang.g:5517:1: rule__ExprEqual__Group_1__0 : rule__ExprEqual__Group_1__0__Impl rule__ExprEqual__Group_1__1 ;
    public final void rule__ExprEqual__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5521:1: ( rule__ExprEqual__Group_1__0__Impl rule__ExprEqual__Group_1__1 )
            // InternalMickeyLang.g:5522:2: rule__ExprEqual__Group_1__0__Impl rule__ExprEqual__Group_1__1
            {
            pushFollow(FOLLOW_39);
            rule__ExprEqual__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprEqual__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group_1__0"


    // $ANTLR start "rule__ExprEqual__Group_1__0__Impl"
    // InternalMickeyLang.g:5529:1: rule__ExprEqual__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprEqual__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5533:1: ( ( () ) )
            // InternalMickeyLang.g:5534:1: ( () )
            {
            // InternalMickeyLang.g:5534:1: ( () )
            // InternalMickeyLang.g:5535:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getExprEqualLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5536:2: ()
            // InternalMickeyLang.g:5536:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getExprEqualLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group_1__0__Impl"


    // $ANTLR start "rule__ExprEqual__Group_1__1"
    // InternalMickeyLang.g:5544:1: rule__ExprEqual__Group_1__1 : rule__ExprEqual__Group_1__1__Impl rule__ExprEqual__Group_1__2 ;
    public final void rule__ExprEqual__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5548:1: ( rule__ExprEqual__Group_1__1__Impl rule__ExprEqual__Group_1__2 )
            // InternalMickeyLang.g:5549:2: rule__ExprEqual__Group_1__1__Impl rule__ExprEqual__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprEqual__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprEqual__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group_1__1"


    // $ANTLR start "rule__ExprEqual__Group_1__1__Impl"
    // InternalMickeyLang.g:5556:1: rule__ExprEqual__Group_1__1__Impl : ( ( rule__ExprEqual__OpAssignment_1_1 ) ) ;
    public final void rule__ExprEqual__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5560:1: ( ( ( rule__ExprEqual__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5561:1: ( ( rule__ExprEqual__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5561:1: ( ( rule__ExprEqual__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5562:2: ( rule__ExprEqual__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5563:2: ( rule__ExprEqual__OpAssignment_1_1 )
            // InternalMickeyLang.g:5563:3: rule__ExprEqual__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprEqual__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group_1__1__Impl"


    // $ANTLR start "rule__ExprEqual__Group_1__2"
    // InternalMickeyLang.g:5571:1: rule__ExprEqual__Group_1__2 : rule__ExprEqual__Group_1__2__Impl ;
    public final void rule__ExprEqual__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5575:1: ( rule__ExprEqual__Group_1__2__Impl )
            // InternalMickeyLang.g:5576:2: rule__ExprEqual__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprEqual__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group_1__2"


    // $ANTLR start "rule__ExprEqual__Group_1__2__Impl"
    // InternalMickeyLang.g:5582:1: rule__ExprEqual__Group_1__2__Impl : ( ( rule__ExprEqual__RightAssignment_1_2 ) ) ;
    public final void rule__ExprEqual__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5586:1: ( ( ( rule__ExprEqual__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5587:1: ( ( rule__ExprEqual__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5587:1: ( ( rule__ExprEqual__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5588:2: ( rule__ExprEqual__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5589:2: ( rule__ExprEqual__RightAssignment_1_2 )
            // InternalMickeyLang.g:5589:3: rule__ExprEqual__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprEqual__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__Group_1__2__Impl"


    // $ANTLR start "rule__ExprAnd__Group__0"
    // InternalMickeyLang.g:5598:1: rule__ExprAnd__Group__0 : rule__ExprAnd__Group__0__Impl rule__ExprAnd__Group__1 ;
    public final void rule__ExprAnd__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5602:1: ( rule__ExprAnd__Group__0__Impl rule__ExprAnd__Group__1 )
            // InternalMickeyLang.g:5603:2: rule__ExprAnd__Group__0__Impl rule__ExprAnd__Group__1
            {
            pushFollow(FOLLOW_41);
            rule__ExprAnd__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprAnd__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group__0"


    // $ANTLR start "rule__ExprAnd__Group__0__Impl"
    // InternalMickeyLang.g:5610:1: rule__ExprAnd__Group__0__Impl : ( ruleExprOr ) ;
    public final void rule__ExprAnd__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5614:1: ( ( ruleExprOr ) )
            // InternalMickeyLang.g:5615:1: ( ruleExprOr )
            {
            // InternalMickeyLang.g:5615:1: ( ruleExprOr )
            // InternalMickeyLang.g:5616:2: ruleExprOr
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getExprOrParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprOr();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getExprOrParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group__0__Impl"


    // $ANTLR start "rule__ExprAnd__Group__1"
    // InternalMickeyLang.g:5625:1: rule__ExprAnd__Group__1 : rule__ExprAnd__Group__1__Impl ;
    public final void rule__ExprAnd__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5629:1: ( rule__ExprAnd__Group__1__Impl )
            // InternalMickeyLang.g:5630:2: rule__ExprAnd__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprAnd__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group__1"


    // $ANTLR start "rule__ExprAnd__Group__1__Impl"
    // InternalMickeyLang.g:5636:1: rule__ExprAnd__Group__1__Impl : ( ( rule__ExprAnd__Group_1__0 )* ) ;
    public final void rule__ExprAnd__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5640:1: ( ( ( rule__ExprAnd__Group_1__0 )* ) )
            // InternalMickeyLang.g:5641:1: ( ( rule__ExprAnd__Group_1__0 )* )
            {
            // InternalMickeyLang.g:5641:1: ( ( rule__ExprAnd__Group_1__0 )* )
            // InternalMickeyLang.g:5642:2: ( rule__ExprAnd__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5643:2: ( rule__ExprAnd__Group_1__0 )*
            loop60:
            do {
                int alt60=2;
                int LA60_0 = input.LA(1);

                if ( (LA60_0==119) ) {
                    alt60=1;
                }


                switch (alt60) {
            	case 1 :
            	    // InternalMickeyLang.g:5643:3: rule__ExprAnd__Group_1__0
            	    {
            	    pushFollow(FOLLOW_42);
            	    rule__ExprAnd__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop60;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group__1__Impl"


    // $ANTLR start "rule__ExprAnd__Group_1__0"
    // InternalMickeyLang.g:5652:1: rule__ExprAnd__Group_1__0 : rule__ExprAnd__Group_1__0__Impl rule__ExprAnd__Group_1__1 ;
    public final void rule__ExprAnd__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5656:1: ( rule__ExprAnd__Group_1__0__Impl rule__ExprAnd__Group_1__1 )
            // InternalMickeyLang.g:5657:2: rule__ExprAnd__Group_1__0__Impl rule__ExprAnd__Group_1__1
            {
            pushFollow(FOLLOW_41);
            rule__ExprAnd__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprAnd__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group_1__0"


    // $ANTLR start "rule__ExprAnd__Group_1__0__Impl"
    // InternalMickeyLang.g:5664:1: rule__ExprAnd__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprAnd__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5668:1: ( ( () ) )
            // InternalMickeyLang.g:5669:1: ( () )
            {
            // InternalMickeyLang.g:5669:1: ( () )
            // InternalMickeyLang.g:5670:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getExprAndLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5671:2: ()
            // InternalMickeyLang.g:5671:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getExprAndLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group_1__0__Impl"


    // $ANTLR start "rule__ExprAnd__Group_1__1"
    // InternalMickeyLang.g:5679:1: rule__ExprAnd__Group_1__1 : rule__ExprAnd__Group_1__1__Impl rule__ExprAnd__Group_1__2 ;
    public final void rule__ExprAnd__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5683:1: ( rule__ExprAnd__Group_1__1__Impl rule__ExprAnd__Group_1__2 )
            // InternalMickeyLang.g:5684:2: rule__ExprAnd__Group_1__1__Impl rule__ExprAnd__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprAnd__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprAnd__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group_1__1"


    // $ANTLR start "rule__ExprAnd__Group_1__1__Impl"
    // InternalMickeyLang.g:5691:1: rule__ExprAnd__Group_1__1__Impl : ( ( rule__ExprAnd__OpAssignment_1_1 ) ) ;
    public final void rule__ExprAnd__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5695:1: ( ( ( rule__ExprAnd__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5696:1: ( ( rule__ExprAnd__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5696:1: ( ( rule__ExprAnd__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5697:2: ( rule__ExprAnd__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5698:2: ( rule__ExprAnd__OpAssignment_1_1 )
            // InternalMickeyLang.g:5698:3: rule__ExprAnd__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprAnd__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group_1__1__Impl"


    // $ANTLR start "rule__ExprAnd__Group_1__2"
    // InternalMickeyLang.g:5706:1: rule__ExprAnd__Group_1__2 : rule__ExprAnd__Group_1__2__Impl ;
    public final void rule__ExprAnd__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5710:1: ( rule__ExprAnd__Group_1__2__Impl )
            // InternalMickeyLang.g:5711:2: rule__ExprAnd__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprAnd__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group_1__2"


    // $ANTLR start "rule__ExprAnd__Group_1__2__Impl"
    // InternalMickeyLang.g:5717:1: rule__ExprAnd__Group_1__2__Impl : ( ( rule__ExprAnd__RightAssignment_1_2 ) ) ;
    public final void rule__ExprAnd__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5721:1: ( ( ( rule__ExprAnd__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5722:1: ( ( rule__ExprAnd__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5722:1: ( ( rule__ExprAnd__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5723:2: ( rule__ExprAnd__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5724:2: ( rule__ExprAnd__RightAssignment_1_2 )
            // InternalMickeyLang.g:5724:3: rule__ExprAnd__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprAnd__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__Group_1__2__Impl"


    // $ANTLR start "rule__ExprOr__Group__0"
    // InternalMickeyLang.g:5733:1: rule__ExprOr__Group__0 : rule__ExprOr__Group__0__Impl rule__ExprOr__Group__1 ;
    public final void rule__ExprOr__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5737:1: ( rule__ExprOr__Group__0__Impl rule__ExprOr__Group__1 )
            // InternalMickeyLang.g:5738:2: rule__ExprOr__Group__0__Impl rule__ExprOr__Group__1
            {
            pushFollow(FOLLOW_43);
            rule__ExprOr__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprOr__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group__0"


    // $ANTLR start "rule__ExprOr__Group__0__Impl"
    // InternalMickeyLang.g:5745:1: rule__ExprOr__Group__0__Impl : ( ruleNullCheckExpression ) ;
    public final void rule__ExprOr__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5749:1: ( ( ruleNullCheckExpression ) )
            // InternalMickeyLang.g:5750:1: ( ruleNullCheckExpression )
            {
            // InternalMickeyLang.g:5750:1: ( ruleNullCheckExpression )
            // InternalMickeyLang.g:5751:2: ruleNullCheckExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getNullCheckExpressionParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNullCheckExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getNullCheckExpressionParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group__0__Impl"


    // $ANTLR start "rule__ExprOr__Group__1"
    // InternalMickeyLang.g:5760:1: rule__ExprOr__Group__1 : rule__ExprOr__Group__1__Impl ;
    public final void rule__ExprOr__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5764:1: ( rule__ExprOr__Group__1__Impl )
            // InternalMickeyLang.g:5765:2: rule__ExprOr__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprOr__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group__1"


    // $ANTLR start "rule__ExprOr__Group__1__Impl"
    // InternalMickeyLang.g:5771:1: rule__ExprOr__Group__1__Impl : ( ( rule__ExprOr__Group_1__0 )* ) ;
    public final void rule__ExprOr__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5775:1: ( ( ( rule__ExprOr__Group_1__0 )* ) )
            // InternalMickeyLang.g:5776:1: ( ( rule__ExprOr__Group_1__0 )* )
            {
            // InternalMickeyLang.g:5776:1: ( ( rule__ExprOr__Group_1__0 )* )
            // InternalMickeyLang.g:5777:2: ( rule__ExprOr__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5778:2: ( rule__ExprOr__Group_1__0 )*
            loop61:
            do {
                int alt61=2;
                int LA61_0 = input.LA(1);

                if ( (LA61_0==114) ) {
                    alt61=1;
                }


                switch (alt61) {
            	case 1 :
            	    // InternalMickeyLang.g:5778:3: rule__ExprOr__Group_1__0
            	    {
            	    pushFollow(FOLLOW_44);
            	    rule__ExprOr__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop61;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group__1__Impl"


    // $ANTLR start "rule__ExprOr__Group_1__0"
    // InternalMickeyLang.g:5787:1: rule__ExprOr__Group_1__0 : rule__ExprOr__Group_1__0__Impl rule__ExprOr__Group_1__1 ;
    public final void rule__ExprOr__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5791:1: ( rule__ExprOr__Group_1__0__Impl rule__ExprOr__Group_1__1 )
            // InternalMickeyLang.g:5792:2: rule__ExprOr__Group_1__0__Impl rule__ExprOr__Group_1__1
            {
            pushFollow(FOLLOW_43);
            rule__ExprOr__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprOr__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group_1__0"


    // $ANTLR start "rule__ExprOr__Group_1__0__Impl"
    // InternalMickeyLang.g:5799:1: rule__ExprOr__Group_1__0__Impl : ( () ) ;
    public final void rule__ExprOr__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5803:1: ( ( () ) )
            // InternalMickeyLang.g:5804:1: ( () )
            {
            // InternalMickeyLang.g:5804:1: ( () )
            // InternalMickeyLang.g:5805:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getExprOrLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5806:2: ()
            // InternalMickeyLang.g:5806:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getExprOrLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group_1__0__Impl"


    // $ANTLR start "rule__ExprOr__Group_1__1"
    // InternalMickeyLang.g:5814:1: rule__ExprOr__Group_1__1 : rule__ExprOr__Group_1__1__Impl rule__ExprOr__Group_1__2 ;
    public final void rule__ExprOr__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5818:1: ( rule__ExprOr__Group_1__1__Impl rule__ExprOr__Group_1__2 )
            // InternalMickeyLang.g:5819:2: rule__ExprOr__Group_1__1__Impl rule__ExprOr__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__ExprOr__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ExprOr__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group_1__1"


    // $ANTLR start "rule__ExprOr__Group_1__1__Impl"
    // InternalMickeyLang.g:5826:1: rule__ExprOr__Group_1__1__Impl : ( ( rule__ExprOr__OpAssignment_1_1 ) ) ;
    public final void rule__ExprOr__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5830:1: ( ( ( rule__ExprOr__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5831:1: ( ( rule__ExprOr__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5831:1: ( ( rule__ExprOr__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:5832:2: ( rule__ExprOr__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5833:2: ( rule__ExprOr__OpAssignment_1_1 )
            // InternalMickeyLang.g:5833:3: rule__ExprOr__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExprOr__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group_1__1__Impl"


    // $ANTLR start "rule__ExprOr__Group_1__2"
    // InternalMickeyLang.g:5841:1: rule__ExprOr__Group_1__2 : rule__ExprOr__Group_1__2__Impl ;
    public final void rule__ExprOr__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5845:1: ( rule__ExprOr__Group_1__2__Impl )
            // InternalMickeyLang.g:5846:2: rule__ExprOr__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExprOr__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group_1__2"


    // $ANTLR start "rule__ExprOr__Group_1__2__Impl"
    // InternalMickeyLang.g:5852:1: rule__ExprOr__Group_1__2__Impl : ( ( rule__ExprOr__RightAssignment_1_2 ) ) ;
    public final void rule__ExprOr__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5856:1: ( ( ( rule__ExprOr__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:5857:1: ( ( rule__ExprOr__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:5857:1: ( ( rule__ExprOr__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:5858:2: ( rule__ExprOr__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:5859:2: ( rule__ExprOr__RightAssignment_1_2 )
            // InternalMickeyLang.g:5859:3: rule__ExprOr__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExprOr__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__Group_1__2__Impl"


    // $ANTLR start "rule__NullCheckExpression__Group__0"
    // InternalMickeyLang.g:5868:1: rule__NullCheckExpression__Group__0 : rule__NullCheckExpression__Group__0__Impl rule__NullCheckExpression__Group__1 ;
    public final void rule__NullCheckExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5872:1: ( rule__NullCheckExpression__Group__0__Impl rule__NullCheckExpression__Group__1 )
            // InternalMickeyLang.g:5873:2: rule__NullCheckExpression__Group__0__Impl rule__NullCheckExpression__Group__1
            {
            pushFollow(FOLLOW_45);
            rule__NullCheckExpression__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NullCheckExpression__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group__0"


    // $ANTLR start "rule__NullCheckExpression__Group__0__Impl"
    // InternalMickeyLang.g:5880:1: rule__NullCheckExpression__Group__0__Impl : ( rulePrimaryExpression ) ;
    public final void rule__NullCheckExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5884:1: ( ( rulePrimaryExpression ) )
            // InternalMickeyLang.g:5885:1: ( rulePrimaryExpression )
            {
            // InternalMickeyLang.g:5885:1: ( rulePrimaryExpression )
            // InternalMickeyLang.g:5886:2: rulePrimaryExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionAccess().getPrimaryExpressionParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePrimaryExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionAccess().getPrimaryExpressionParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group__0__Impl"


    // $ANTLR start "rule__NullCheckExpression__Group__1"
    // InternalMickeyLang.g:5895:1: rule__NullCheckExpression__Group__1 : rule__NullCheckExpression__Group__1__Impl ;
    public final void rule__NullCheckExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5899:1: ( rule__NullCheckExpression__Group__1__Impl )
            // InternalMickeyLang.g:5900:2: rule__NullCheckExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NullCheckExpression__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group__1"


    // $ANTLR start "rule__NullCheckExpression__Group__1__Impl"
    // InternalMickeyLang.g:5906:1: rule__NullCheckExpression__Group__1__Impl : ( ( rule__NullCheckExpression__Group_1__0 )? ) ;
    public final void rule__NullCheckExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5910:1: ( ( ( rule__NullCheckExpression__Group_1__0 )? ) )
            // InternalMickeyLang.g:5911:1: ( ( rule__NullCheckExpression__Group_1__0 )? )
            {
            // InternalMickeyLang.g:5911:1: ( ( rule__NullCheckExpression__Group_1__0 )? )
            // InternalMickeyLang.g:5912:2: ( rule__NullCheckExpression__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:5913:2: ( rule__NullCheckExpression__Group_1__0 )?
            int alt62=2;
            int LA62_0 = input.LA(1);

            if ( ((LA62_0>=37 && LA62_0<=38)||LA62_0==74) ) {
                alt62=1;
            }
            switch (alt62) {
                case 1 :
                    // InternalMickeyLang.g:5913:3: rule__NullCheckExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__NullCheckExpression__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group__1__Impl"


    // $ANTLR start "rule__NullCheckExpression__Group_1__0"
    // InternalMickeyLang.g:5922:1: rule__NullCheckExpression__Group_1__0 : rule__NullCheckExpression__Group_1__0__Impl rule__NullCheckExpression__Group_1__1 ;
    public final void rule__NullCheckExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5926:1: ( rule__NullCheckExpression__Group_1__0__Impl rule__NullCheckExpression__Group_1__1 )
            // InternalMickeyLang.g:5927:2: rule__NullCheckExpression__Group_1__0__Impl rule__NullCheckExpression__Group_1__1
            {
            pushFollow(FOLLOW_45);
            rule__NullCheckExpression__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NullCheckExpression__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group_1__0"


    // $ANTLR start "rule__NullCheckExpression__Group_1__0__Impl"
    // InternalMickeyLang.g:5934:1: rule__NullCheckExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__NullCheckExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5938:1: ( ( () ) )
            // InternalMickeyLang.g:5939:1: ( () )
            {
            // InternalMickeyLang.g:5939:1: ( () )
            // InternalMickeyLang.g:5940:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionAccess().getNullCheckExpressionLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:5941:2: ()
            // InternalMickeyLang.g:5941:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionAccess().getNullCheckExpressionLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group_1__0__Impl"


    // $ANTLR start "rule__NullCheckExpression__Group_1__1"
    // InternalMickeyLang.g:5949:1: rule__NullCheckExpression__Group_1__1 : rule__NullCheckExpression__Group_1__1__Impl ;
    public final void rule__NullCheckExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5953:1: ( rule__NullCheckExpression__Group_1__1__Impl )
            // InternalMickeyLang.g:5954:2: rule__NullCheckExpression__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NullCheckExpression__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group_1__1"


    // $ANTLR start "rule__NullCheckExpression__Group_1__1__Impl"
    // InternalMickeyLang.g:5960:1: rule__NullCheckExpression__Group_1__1__Impl : ( ( rule__NullCheckExpression__RightAssignment_1_1 ) ) ;
    public final void rule__NullCheckExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5964:1: ( ( ( rule__NullCheckExpression__RightAssignment_1_1 ) ) )
            // InternalMickeyLang.g:5965:1: ( ( rule__NullCheckExpression__RightAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:5965:1: ( ( rule__NullCheckExpression__RightAssignment_1_1 ) )
            // InternalMickeyLang.g:5966:2: ( rule__NullCheckExpression__RightAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionAccess().getRightAssignment_1_1()); 
            }
            // InternalMickeyLang.g:5967:2: ( rule__NullCheckExpression__RightAssignment_1_1 )
            // InternalMickeyLang.g:5967:3: rule__NullCheckExpression__RightAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__NullCheckExpression__RightAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionAccess().getRightAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__Group_1__1__Impl"


    // $ANTLR start "rule__NullExpression__Group_0__0"
    // InternalMickeyLang.g:5976:1: rule__NullExpression__Group_0__0 : rule__NullExpression__Group_0__0__Impl rule__NullExpression__Group_0__1 ;
    public final void rule__NullExpression__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5980:1: ( rule__NullExpression__Group_0__0__Impl rule__NullExpression__Group_0__1 )
            // InternalMickeyLang.g:5981:2: rule__NullExpression__Group_0__0__Impl rule__NullExpression__Group_0__1
            {
            pushFollow(FOLLOW_46);
            rule__NullExpression__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NullExpression__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_0__0"


    // $ANTLR start "rule__NullExpression__Group_0__0__Impl"
    // InternalMickeyLang.g:5988:1: rule__NullExpression__Group_0__0__Impl : ( () ) ;
    public final void rule__NullExpression__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:5992:1: ( ( () ) )
            // InternalMickeyLang.g:5993:1: ( () )
            {
            // InternalMickeyLang.g:5993:1: ( () )
            // InternalMickeyLang.g:5994:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullExpressionAccess().getIsNullAction_0_0()); 
            }
            // InternalMickeyLang.g:5995:2: ()
            // InternalMickeyLang.g:5995:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullExpressionAccess().getIsNullAction_0_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_0__0__Impl"


    // $ANTLR start "rule__NullExpression__Group_0__1"
    // InternalMickeyLang.g:6003:1: rule__NullExpression__Group_0__1 : rule__NullExpression__Group_0__1__Impl ;
    public final void rule__NullExpression__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6007:1: ( rule__NullExpression__Group_0__1__Impl )
            // InternalMickeyLang.g:6008:2: rule__NullExpression__Group_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NullExpression__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_0__1"


    // $ANTLR start "rule__NullExpression__Group_0__1__Impl"
    // InternalMickeyLang.g:6014:1: rule__NullExpression__Group_0__1__Impl : ( 'is null' ) ;
    public final void rule__NullExpression__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6018:1: ( ( 'is null' ) )
            // InternalMickeyLang.g:6019:1: ( 'is null' )
            {
            // InternalMickeyLang.g:6019:1: ( 'is null' )
            // InternalMickeyLang.g:6020:2: 'is null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullExpressionAccess().getIsNullKeyword_0_1()); 
            }
            match(input,74,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullExpressionAccess().getIsNullKeyword_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_0__1__Impl"


    // $ANTLR start "rule__NullExpression__Group_1__0"
    // InternalMickeyLang.g:6030:1: rule__NullExpression__Group_1__0 : rule__NullExpression__Group_1__0__Impl rule__NullExpression__Group_1__1 ;
    public final void rule__NullExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6034:1: ( rule__NullExpression__Group_1__0__Impl rule__NullExpression__Group_1__1 )
            // InternalMickeyLang.g:6035:2: rule__NullExpression__Group_1__0__Impl rule__NullExpression__Group_1__1
            {
            pushFollow(FOLLOW_45);
            rule__NullExpression__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__NullExpression__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_1__0"


    // $ANTLR start "rule__NullExpression__Group_1__0__Impl"
    // InternalMickeyLang.g:6042:1: rule__NullExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__NullExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6046:1: ( ( () ) )
            // InternalMickeyLang.g:6047:1: ( () )
            {
            // InternalMickeyLang.g:6047:1: ( () )
            // InternalMickeyLang.g:6048:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullExpressionAccess().getNotNullAction_1_0()); 
            }
            // InternalMickeyLang.g:6049:2: ()
            // InternalMickeyLang.g:6049:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullExpressionAccess().getNotNullAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_1__0__Impl"


    // $ANTLR start "rule__NullExpression__Group_1__1"
    // InternalMickeyLang.g:6057:1: rule__NullExpression__Group_1__1 : rule__NullExpression__Group_1__1__Impl ;
    public final void rule__NullExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6061:1: ( rule__NullExpression__Group_1__1__Impl )
            // InternalMickeyLang.g:6062:2: rule__NullExpression__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NullExpression__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_1__1"


    // $ANTLR start "rule__NullExpression__Group_1__1__Impl"
    // InternalMickeyLang.g:6068:1: rule__NullExpression__Group_1__1__Impl : ( ( rule__NullExpression__Alternatives_1_1 ) ) ;
    public final void rule__NullExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6072:1: ( ( ( rule__NullExpression__Alternatives_1_1 ) ) )
            // InternalMickeyLang.g:6073:1: ( ( rule__NullExpression__Alternatives_1_1 ) )
            {
            // InternalMickeyLang.g:6073:1: ( ( rule__NullExpression__Alternatives_1_1 ) )
            // InternalMickeyLang.g:6074:2: ( rule__NullExpression__Alternatives_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullExpressionAccess().getAlternatives_1_1()); 
            }
            // InternalMickeyLang.g:6075:2: ( rule__NullExpression__Alternatives_1_1 )
            // InternalMickeyLang.g:6075:3: rule__NullExpression__Alternatives_1_1
            {
            pushFollow(FOLLOW_2);
            rule__NullExpression__Alternatives_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullExpressionAccess().getAlternatives_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullExpression__Group_1__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_0__0"
    // InternalMickeyLang.g:6084:1: rule__PrimaryExpression__Group_0__0 : rule__PrimaryExpression__Group_0__0__Impl rule__PrimaryExpression__Group_0__1 ;
    public final void rule__PrimaryExpression__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6088:1: ( rule__PrimaryExpression__Group_0__0__Impl rule__PrimaryExpression__Group_0__1 )
            // InternalMickeyLang.g:6089:2: rule__PrimaryExpression__Group_0__0__Impl rule__PrimaryExpression__Group_0__1
            {
            pushFollow(FOLLOW_47);
            rule__PrimaryExpression__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_0__0"


    // $ANTLR start "rule__PrimaryExpression__Group_0__0__Impl"
    // InternalMickeyLang.g:6096:1: rule__PrimaryExpression__Group_0__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6100:1: ( ( () ) )
            // InternalMickeyLang.g:6101:1: ( () )
            {
            // InternalMickeyLang.g:6101:1: ( () )
            // InternalMickeyLang.g:6102:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNewColumnAction_0_0()); 
            }
            // InternalMickeyLang.g:6103:2: ()
            // InternalMickeyLang.g:6103:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNewColumnAction_0_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_0__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_0__1"
    // InternalMickeyLang.g:6111:1: rule__PrimaryExpression__Group_0__1 : rule__PrimaryExpression__Group_0__1__Impl rule__PrimaryExpression__Group_0__2 ;
    public final void rule__PrimaryExpression__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6115:1: ( rule__PrimaryExpression__Group_0__1__Impl rule__PrimaryExpression__Group_0__2 )
            // InternalMickeyLang.g:6116:2: rule__PrimaryExpression__Group_0__1__Impl rule__PrimaryExpression__Group_0__2
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryExpression__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_0__1"


    // $ANTLR start "rule__PrimaryExpression__Group_0__1__Impl"
    // InternalMickeyLang.g:6123:1: rule__PrimaryExpression__Group_0__1__Impl : ( 'new.' ) ;
    public final void rule__PrimaryExpression__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6127:1: ( ( 'new.' ) )
            // InternalMickeyLang.g:6128:1: ( 'new.' )
            {
            // InternalMickeyLang.g:6128:1: ( 'new.' )
            // InternalMickeyLang.g:6129:2: 'new.'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNewKeyword_0_1()); 
            }
            match(input,75,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNewKeyword_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_0__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_0__2"
    // InternalMickeyLang.g:6138:1: rule__PrimaryExpression__Group_0__2 : rule__PrimaryExpression__Group_0__2__Impl ;
    public final void rule__PrimaryExpression__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6142:1: ( rule__PrimaryExpression__Group_0__2__Impl )
            // InternalMickeyLang.g:6143:2: rule__PrimaryExpression__Group_0__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_0__2"


    // $ANTLR start "rule__PrimaryExpression__Group_0__2__Impl"
    // InternalMickeyLang.g:6149:1: rule__PrimaryExpression__Group_0__2__Impl : ( ( rule__PrimaryExpression__ColumnAssignment_0_2 ) ) ;
    public final void rule__PrimaryExpression__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6153:1: ( ( ( rule__PrimaryExpression__ColumnAssignment_0_2 ) ) )
            // InternalMickeyLang.g:6154:1: ( ( rule__PrimaryExpression__ColumnAssignment_0_2 ) )
            {
            // InternalMickeyLang.g:6154:1: ( ( rule__PrimaryExpression__ColumnAssignment_0_2 ) )
            // InternalMickeyLang.g:6155:2: ( rule__PrimaryExpression__ColumnAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_0_2()); 
            }
            // InternalMickeyLang.g:6156:2: ( rule__PrimaryExpression__ColumnAssignment_0_2 )
            // InternalMickeyLang.g:6156:3: rule__PrimaryExpression__ColumnAssignment_0_2
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ColumnAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_0_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_0__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_1__0"
    // InternalMickeyLang.g:6165:1: rule__PrimaryExpression__Group_1__0 : rule__PrimaryExpression__Group_1__0__Impl rule__PrimaryExpression__Group_1__1 ;
    public final void rule__PrimaryExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6169:1: ( rule__PrimaryExpression__Group_1__0__Impl rule__PrimaryExpression__Group_1__1 )
            // InternalMickeyLang.g:6170:2: rule__PrimaryExpression__Group_1__0__Impl rule__PrimaryExpression__Group_1__1
            {
            pushFollow(FOLLOW_48);
            rule__PrimaryExpression__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_1__0"


    // $ANTLR start "rule__PrimaryExpression__Group_1__0__Impl"
    // InternalMickeyLang.g:6177:1: rule__PrimaryExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6181:1: ( ( () ) )
            // InternalMickeyLang.g:6182:1: ( () )
            {
            // InternalMickeyLang.g:6182:1: ( () )
            // InternalMickeyLang.g:6183:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getOldColumnAction_1_0()); 
            }
            // InternalMickeyLang.g:6184:2: ()
            // InternalMickeyLang.g:6184:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getOldColumnAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_1__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_1__1"
    // InternalMickeyLang.g:6192:1: rule__PrimaryExpression__Group_1__1 : rule__PrimaryExpression__Group_1__1__Impl rule__PrimaryExpression__Group_1__2 ;
    public final void rule__PrimaryExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6196:1: ( rule__PrimaryExpression__Group_1__1__Impl rule__PrimaryExpression__Group_1__2 )
            // InternalMickeyLang.g:6197:2: rule__PrimaryExpression__Group_1__1__Impl rule__PrimaryExpression__Group_1__2
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryExpression__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_1__1"


    // $ANTLR start "rule__PrimaryExpression__Group_1__1__Impl"
    // InternalMickeyLang.g:6204:1: rule__PrimaryExpression__Group_1__1__Impl : ( 'old.' ) ;
    public final void rule__PrimaryExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6208:1: ( ( 'old.' ) )
            // InternalMickeyLang.g:6209:1: ( 'old.' )
            {
            // InternalMickeyLang.g:6209:1: ( 'old.' )
            // InternalMickeyLang.g:6210:2: 'old.'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getOldKeyword_1_1()); 
            }
            match(input,76,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getOldKeyword_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_1__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_1__2"
    // InternalMickeyLang.g:6219:1: rule__PrimaryExpression__Group_1__2 : rule__PrimaryExpression__Group_1__2__Impl ;
    public final void rule__PrimaryExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6223:1: ( rule__PrimaryExpression__Group_1__2__Impl )
            // InternalMickeyLang.g:6224:2: rule__PrimaryExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_1__2"


    // $ANTLR start "rule__PrimaryExpression__Group_1__2__Impl"
    // InternalMickeyLang.g:6230:1: rule__PrimaryExpression__Group_1__2__Impl : ( ( rule__PrimaryExpression__ColumnAssignment_1_2 ) ) ;
    public final void rule__PrimaryExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6234:1: ( ( ( rule__PrimaryExpression__ColumnAssignment_1_2 ) ) )
            // InternalMickeyLang.g:6235:1: ( ( rule__PrimaryExpression__ColumnAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:6235:1: ( ( rule__PrimaryExpression__ColumnAssignment_1_2 ) )
            // InternalMickeyLang.g:6236:2: ( rule__PrimaryExpression__ColumnAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_1_2()); 
            }
            // InternalMickeyLang.g:6237:2: ( rule__PrimaryExpression__ColumnAssignment_1_2 )
            // InternalMickeyLang.g:6237:3: rule__PrimaryExpression__ColumnAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ColumnAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_1__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2__0"
    // InternalMickeyLang.g:6246:1: rule__PrimaryExpression__Group_2__0 : rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 ;
    public final void rule__PrimaryExpression__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6250:1: ( rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 )
            // InternalMickeyLang.g:6251:2: rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryExpression__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2__0"


    // $ANTLR start "rule__PrimaryExpression__Group_2__0__Impl"
    // InternalMickeyLang.g:6258:1: rule__PrimaryExpression__Group_2__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6262:1: ( ( () ) )
            // InternalMickeyLang.g:6263:1: ( () )
            {
            // InternalMickeyLang.g:6263:1: ( () )
            // InternalMickeyLang.g:6264:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnSourceRefAction_2_0()); 
            }
            // InternalMickeyLang.g:6265:2: ()
            // InternalMickeyLang.g:6265:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnSourceRefAction_2_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2__1"
    // InternalMickeyLang.g:6273:1: rule__PrimaryExpression__Group_2__1 : rule__PrimaryExpression__Group_2__1__Impl ;
    public final void rule__PrimaryExpression__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6277:1: ( rule__PrimaryExpression__Group_2__1__Impl )
            // InternalMickeyLang.g:6278:2: rule__PrimaryExpression__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2__1"


    // $ANTLR start "rule__PrimaryExpression__Group_2__1__Impl"
    // InternalMickeyLang.g:6284:1: rule__PrimaryExpression__Group_2__1__Impl : ( ( rule__PrimaryExpression__Alternatives_2_1 ) ) ;
    public final void rule__PrimaryExpression__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6288:1: ( ( ( rule__PrimaryExpression__Alternatives_2_1 ) ) )
            // InternalMickeyLang.g:6289:1: ( ( rule__PrimaryExpression__Alternatives_2_1 ) )
            {
            // InternalMickeyLang.g:6289:1: ( ( rule__PrimaryExpression__Alternatives_2_1 ) )
            // InternalMickeyLang.g:6290:2: ( rule__PrimaryExpression__Alternatives_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAlternatives_2_1()); 
            }
            // InternalMickeyLang.g:6291:2: ( rule__PrimaryExpression__Alternatives_2_1 )
            // InternalMickeyLang.g:6291:3: rule__PrimaryExpression__Alternatives_2_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Alternatives_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAlternatives_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_0__0"
    // InternalMickeyLang.g:6300:1: rule__PrimaryExpression__Group_2_1_0__0 : rule__PrimaryExpression__Group_2_1_0__0__Impl rule__PrimaryExpression__Group_2_1_0__1 ;
    public final void rule__PrimaryExpression__Group_2_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6304:1: ( rule__PrimaryExpression__Group_2_1_0__0__Impl rule__PrimaryExpression__Group_2_1_0__1 )
            // InternalMickeyLang.g:6305:2: rule__PrimaryExpression__Group_2_1_0__0__Impl rule__PrimaryExpression__Group_2_1_0__1
            {
            pushFollow(FOLLOW_49);
            rule__PrimaryExpression__Group_2_1_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2_1_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_0__0"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_0__0__Impl"
    // InternalMickeyLang.g:6312:1: rule__PrimaryExpression__Group_2_1_0__0__Impl : ( ( rule__PrimaryExpression__SourceAssignment_2_1_0_0 ) ) ;
    public final void rule__PrimaryExpression__Group_2_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6316:1: ( ( ( rule__PrimaryExpression__SourceAssignment_2_1_0_0 ) ) )
            // InternalMickeyLang.g:6317:1: ( ( rule__PrimaryExpression__SourceAssignment_2_1_0_0 ) )
            {
            // InternalMickeyLang.g:6317:1: ( ( rule__PrimaryExpression__SourceAssignment_2_1_0_0 ) )
            // InternalMickeyLang.g:6318:2: ( rule__PrimaryExpression__SourceAssignment_2_1_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSourceAssignment_2_1_0_0()); 
            }
            // InternalMickeyLang.g:6319:2: ( rule__PrimaryExpression__SourceAssignment_2_1_0_0 )
            // InternalMickeyLang.g:6319:3: rule__PrimaryExpression__SourceAssignment_2_1_0_0
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__SourceAssignment_2_1_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSourceAssignment_2_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_0__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_0__1"
    // InternalMickeyLang.g:6327:1: rule__PrimaryExpression__Group_2_1_0__1 : rule__PrimaryExpression__Group_2_1_0__1__Impl ;
    public final void rule__PrimaryExpression__Group_2_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6331:1: ( rule__PrimaryExpression__Group_2_1_0__1__Impl )
            // InternalMickeyLang.g:6332:2: rule__PrimaryExpression__Group_2_1_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2_1_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_0__1"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_0__1__Impl"
    // InternalMickeyLang.g:6338:1: rule__PrimaryExpression__Group_2_1_0__1__Impl : ( '.' ) ;
    public final void rule__PrimaryExpression__Group_2_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6342:1: ( ( '.' ) )
            // InternalMickeyLang.g:6343:1: ( '.' )
            {
            // InternalMickeyLang.g:6343:1: ( '.' )
            // InternalMickeyLang.g:6344:2: '.'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getFullStopKeyword_2_1_0_1()); 
            }
            match(input,77,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getFullStopKeyword_2_1_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_0__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_1__0"
    // InternalMickeyLang.g:6354:1: rule__PrimaryExpression__Group_2_1_1__0 : rule__PrimaryExpression__Group_2_1_1__0__Impl rule__PrimaryExpression__Group_2_1_1__1 ;
    public final void rule__PrimaryExpression__Group_2_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6358:1: ( rule__PrimaryExpression__Group_2_1_1__0__Impl rule__PrimaryExpression__Group_2_1_1__1 )
            // InternalMickeyLang.g:6359:2: rule__PrimaryExpression__Group_2_1_1__0__Impl rule__PrimaryExpression__Group_2_1_1__1
            {
            pushFollow(FOLLOW_49);
            rule__PrimaryExpression__Group_2_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_1__0"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_1__0__Impl"
    // InternalMickeyLang.g:6366:1: rule__PrimaryExpression__Group_2_1_1__0__Impl : ( ( rule__PrimaryExpression__SourceAssignment_2_1_1_0 ) ) ;
    public final void rule__PrimaryExpression__Group_2_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6370:1: ( ( ( rule__PrimaryExpression__SourceAssignment_2_1_1_0 ) ) )
            // InternalMickeyLang.g:6371:1: ( ( rule__PrimaryExpression__SourceAssignment_2_1_1_0 ) )
            {
            // InternalMickeyLang.g:6371:1: ( ( rule__PrimaryExpression__SourceAssignment_2_1_1_0 ) )
            // InternalMickeyLang.g:6372:2: ( rule__PrimaryExpression__SourceAssignment_2_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSourceAssignment_2_1_1_0()); 
            }
            // InternalMickeyLang.g:6373:2: ( rule__PrimaryExpression__SourceAssignment_2_1_1_0 )
            // InternalMickeyLang.g:6373:3: rule__PrimaryExpression__SourceAssignment_2_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__SourceAssignment_2_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSourceAssignment_2_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_1__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_1__1"
    // InternalMickeyLang.g:6381:1: rule__PrimaryExpression__Group_2_1_1__1 : rule__PrimaryExpression__Group_2_1_1__1__Impl rule__PrimaryExpression__Group_2_1_1__2 ;
    public final void rule__PrimaryExpression__Group_2_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6385:1: ( rule__PrimaryExpression__Group_2_1_1__1__Impl rule__PrimaryExpression__Group_2_1_1__2 )
            // InternalMickeyLang.g:6386:2: rule__PrimaryExpression__Group_2_1_1__1__Impl rule__PrimaryExpression__Group_2_1_1__2
            {
            pushFollow(FOLLOW_50);
            rule__PrimaryExpression__Group_2_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_1__1"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_1__1__Impl"
    // InternalMickeyLang.g:6393:1: rule__PrimaryExpression__Group_2_1_1__1__Impl : ( '.' ) ;
    public final void rule__PrimaryExpression__Group_2_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6397:1: ( ( '.' ) )
            // InternalMickeyLang.g:6398:1: ( '.' )
            {
            // InternalMickeyLang.g:6398:1: ( '.' )
            // InternalMickeyLang.g:6399:2: '.'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getFullStopKeyword_2_1_1_1()); 
            }
            match(input,77,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getFullStopKeyword_2_1_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_1__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_1__2"
    // InternalMickeyLang.g:6408:1: rule__PrimaryExpression__Group_2_1_1__2 : rule__PrimaryExpression__Group_2_1_1__2__Impl ;
    public final void rule__PrimaryExpression__Group_2_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6412:1: ( rule__PrimaryExpression__Group_2_1_1__2__Impl )
            // InternalMickeyLang.g:6413:2: rule__PrimaryExpression__Group_2_1_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_2_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_1__2"


    // $ANTLR start "rule__PrimaryExpression__Group_2_1_1__2__Impl"
    // InternalMickeyLang.g:6419:1: rule__PrimaryExpression__Group_2_1_1__2__Impl : ( ( rule__PrimaryExpression__Alternatives_2_1_1_2 ) ) ;
    public final void rule__PrimaryExpression__Group_2_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6423:1: ( ( ( rule__PrimaryExpression__Alternatives_2_1_1_2 ) ) )
            // InternalMickeyLang.g:6424:1: ( ( rule__PrimaryExpression__Alternatives_2_1_1_2 ) )
            {
            // InternalMickeyLang.g:6424:1: ( ( rule__PrimaryExpression__Alternatives_2_1_1_2 ) )
            // InternalMickeyLang.g:6425:2: ( rule__PrimaryExpression__Alternatives_2_1_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAlternatives_2_1_1_2()); 
            }
            // InternalMickeyLang.g:6426:2: ( rule__PrimaryExpression__Alternatives_2_1_1_2 )
            // InternalMickeyLang.g:6426:3: rule__PrimaryExpression__Alternatives_2_1_1_2
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Alternatives_2_1_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAlternatives_2_1_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_2_1_1__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_3__0"
    // InternalMickeyLang.g:6435:1: rule__PrimaryExpression__Group_3__0 : rule__PrimaryExpression__Group_3__0__Impl rule__PrimaryExpression__Group_3__1 ;
    public final void rule__PrimaryExpression__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6439:1: ( rule__PrimaryExpression__Group_3__0__Impl rule__PrimaryExpression__Group_3__1 )
            // InternalMickeyLang.g:6440:2: rule__PrimaryExpression__Group_3__0__Impl rule__PrimaryExpression__Group_3__1
            {
            pushFollow(FOLLOW_51);
            rule__PrimaryExpression__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_3__0"


    // $ANTLR start "rule__PrimaryExpression__Group_3__0__Impl"
    // InternalMickeyLang.g:6447:1: rule__PrimaryExpression__Group_3__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6451:1: ( ( () ) )
            // InternalMickeyLang.g:6452:1: ( () )
            {
            // InternalMickeyLang.g:6452:1: ( () )
            // InternalMickeyLang.g:6453:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLiteralAction_3_0()); 
            }
            // InternalMickeyLang.g:6454:2: ()
            // InternalMickeyLang.g:6454:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLiteralAction_3_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_3__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_3__1"
    // InternalMickeyLang.g:6462:1: rule__PrimaryExpression__Group_3__1 : rule__PrimaryExpression__Group_3__1__Impl ;
    public final void rule__PrimaryExpression__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6466:1: ( rule__PrimaryExpression__Group_3__1__Impl )
            // InternalMickeyLang.g:6467:2: rule__PrimaryExpression__Group_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_3__1"


    // $ANTLR start "rule__PrimaryExpression__Group_3__1__Impl"
    // InternalMickeyLang.g:6473:1: rule__PrimaryExpression__Group_3__1__Impl : ( ( rule__PrimaryExpression__LiteralValueAssignment_3_1 ) ) ;
    public final void rule__PrimaryExpression__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6477:1: ( ( ( rule__PrimaryExpression__LiteralValueAssignment_3_1 ) ) )
            // InternalMickeyLang.g:6478:1: ( ( rule__PrimaryExpression__LiteralValueAssignment_3_1 ) )
            {
            // InternalMickeyLang.g:6478:1: ( ( rule__PrimaryExpression__LiteralValueAssignment_3_1 ) )
            // InternalMickeyLang.g:6479:2: ( rule__PrimaryExpression__LiteralValueAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLiteralValueAssignment_3_1()); 
            }
            // InternalMickeyLang.g:6480:2: ( rule__PrimaryExpression__LiteralValueAssignment_3_1 )
            // InternalMickeyLang.g:6480:3: rule__PrimaryExpression__LiteralValueAssignment_3_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__LiteralValueAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLiteralValueAssignment_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_3__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_4__0"
    // InternalMickeyLang.g:6489:1: rule__PrimaryExpression__Group_4__0 : rule__PrimaryExpression__Group_4__0__Impl rule__PrimaryExpression__Group_4__1 ;
    public final void rule__PrimaryExpression__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6493:1: ( rule__PrimaryExpression__Group_4__0__Impl rule__PrimaryExpression__Group_4__1 )
            // InternalMickeyLang.g:6494:2: rule__PrimaryExpression__Group_4__0__Impl rule__PrimaryExpression__Group_4__1
            {
            pushFollow(FOLLOW_6);
            rule__PrimaryExpression__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__0"


    // $ANTLR start "rule__PrimaryExpression__Group_4__0__Impl"
    // InternalMickeyLang.g:6501:1: rule__PrimaryExpression__Group_4__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6505:1: ( ( () ) )
            // InternalMickeyLang.g:6506:1: ( () )
            {
            // InternalMickeyLang.g:6506:1: ( () )
            // InternalMickeyLang.g:6507:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNestedExpressionAction_4_0()); 
            }
            // InternalMickeyLang.g:6508:2: ()
            // InternalMickeyLang.g:6508:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNestedExpressionAction_4_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_4__1"
    // InternalMickeyLang.g:6516:1: rule__PrimaryExpression__Group_4__1 : rule__PrimaryExpression__Group_4__1__Impl rule__PrimaryExpression__Group_4__2 ;
    public final void rule__PrimaryExpression__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6520:1: ( rule__PrimaryExpression__Group_4__1__Impl rule__PrimaryExpression__Group_4__2 )
            // InternalMickeyLang.g:6521:2: rule__PrimaryExpression__Group_4__1__Impl rule__PrimaryExpression__Group_4__2
            {
            pushFollow(FOLLOW_30);
            rule__PrimaryExpression__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_4__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__1"


    // $ANTLR start "rule__PrimaryExpression__Group_4__1__Impl"
    // InternalMickeyLang.g:6528:1: rule__PrimaryExpression__Group_4__1__Impl : ( '(' ) ;
    public final void rule__PrimaryExpression__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6532:1: ( ( '(' ) )
            // InternalMickeyLang.g:6533:1: ( '(' )
            {
            // InternalMickeyLang.g:6533:1: ( '(' )
            // InternalMickeyLang.g:6534:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_4_1()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_4__2"
    // InternalMickeyLang.g:6543:1: rule__PrimaryExpression__Group_4__2 : rule__PrimaryExpression__Group_4__2__Impl rule__PrimaryExpression__Group_4__3 ;
    public final void rule__PrimaryExpression__Group_4__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6547:1: ( rule__PrimaryExpression__Group_4__2__Impl rule__PrimaryExpression__Group_4__3 )
            // InternalMickeyLang.g:6548:2: rule__PrimaryExpression__Group_4__2__Impl rule__PrimaryExpression__Group_4__3
            {
            pushFollow(FOLLOW_52);
            rule__PrimaryExpression__Group_4__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_4__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__2"


    // $ANTLR start "rule__PrimaryExpression__Group_4__2__Impl"
    // InternalMickeyLang.g:6555:1: rule__PrimaryExpression__Group_4__2__Impl : ( ( rule__PrimaryExpression__ExpressionAssignment_4_2 ) ) ;
    public final void rule__PrimaryExpression__Group_4__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6559:1: ( ( ( rule__PrimaryExpression__ExpressionAssignment_4_2 ) ) )
            // InternalMickeyLang.g:6560:1: ( ( rule__PrimaryExpression__ExpressionAssignment_4_2 ) )
            {
            // InternalMickeyLang.g:6560:1: ( ( rule__PrimaryExpression__ExpressionAssignment_4_2 ) )
            // InternalMickeyLang.g:6561:2: ( rule__PrimaryExpression__ExpressionAssignment_4_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExpressionAssignment_4_2()); 
            }
            // InternalMickeyLang.g:6562:2: ( rule__PrimaryExpression__ExpressionAssignment_4_2 )
            // InternalMickeyLang.g:6562:3: rule__PrimaryExpression__ExpressionAssignment_4_2
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ExpressionAssignment_4_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExpressionAssignment_4_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_4__3"
    // InternalMickeyLang.g:6570:1: rule__PrimaryExpression__Group_4__3 : rule__PrimaryExpression__Group_4__3__Impl ;
    public final void rule__PrimaryExpression__Group_4__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6574:1: ( rule__PrimaryExpression__Group_4__3__Impl )
            // InternalMickeyLang.g:6575:2: rule__PrimaryExpression__Group_4__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_4__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__3"


    // $ANTLR start "rule__PrimaryExpression__Group_4__3__Impl"
    // InternalMickeyLang.g:6581:1: rule__PrimaryExpression__Group_4__3__Impl : ( ')' ) ;
    public final void rule__PrimaryExpression__Group_4__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6585:1: ( ( ')' ) )
            // InternalMickeyLang.g:6586:1: ( ')' )
            {
            // InternalMickeyLang.g:6586:1: ( ')' )
            // InternalMickeyLang.g:6587:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_4_3()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_4_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_4__3__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_5__0"
    // InternalMickeyLang.g:6597:1: rule__PrimaryExpression__Group_5__0 : rule__PrimaryExpression__Group_5__0__Impl rule__PrimaryExpression__Group_5__1 ;
    public final void rule__PrimaryExpression__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6601:1: ( rule__PrimaryExpression__Group_5__0__Impl rule__PrimaryExpression__Group_5__1 )
            // InternalMickeyLang.g:6602:2: rule__PrimaryExpression__Group_5__0__Impl rule__PrimaryExpression__Group_5__1
            {
            pushFollow(FOLLOW_53);
            rule__PrimaryExpression__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__0"


    // $ANTLR start "rule__PrimaryExpression__Group_5__0__Impl"
    // InternalMickeyLang.g:6609:1: rule__PrimaryExpression__Group_5__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6613:1: ( ( () ) )
            // InternalMickeyLang.g:6614:1: ( () )
            {
            // InternalMickeyLang.g:6614:1: ( () )
            // InternalMickeyLang.g:6615:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSelectStatementExpressionAction_5_0()); 
            }
            // InternalMickeyLang.g:6616:2: ()
            // InternalMickeyLang.g:6616:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSelectStatementExpressionAction_5_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_5__1"
    // InternalMickeyLang.g:6624:1: rule__PrimaryExpression__Group_5__1 : rule__PrimaryExpression__Group_5__1__Impl rule__PrimaryExpression__Group_5__2 ;
    public final void rule__PrimaryExpression__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6628:1: ( rule__PrimaryExpression__Group_5__1__Impl rule__PrimaryExpression__Group_5__2 )
            // InternalMickeyLang.g:6629:2: rule__PrimaryExpression__Group_5__1__Impl rule__PrimaryExpression__Group_5__2
            {
            pushFollow(FOLLOW_53);
            rule__PrimaryExpression__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_5__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__1"


    // $ANTLR start "rule__PrimaryExpression__Group_5__1__Impl"
    // InternalMickeyLang.g:6636:1: rule__PrimaryExpression__Group_5__1__Impl : ( ( rule__PrimaryExpression__NotAssignment_5_1 )? ) ;
    public final void rule__PrimaryExpression__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6640:1: ( ( ( rule__PrimaryExpression__NotAssignment_5_1 )? ) )
            // InternalMickeyLang.g:6641:1: ( ( rule__PrimaryExpression__NotAssignment_5_1 )? )
            {
            // InternalMickeyLang.g:6641:1: ( ( rule__PrimaryExpression__NotAssignment_5_1 )? )
            // InternalMickeyLang.g:6642:2: ( rule__PrimaryExpression__NotAssignment_5_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNotAssignment_5_1()); 
            }
            // InternalMickeyLang.g:6643:2: ( rule__PrimaryExpression__NotAssignment_5_1 )?
            int alt63=2;
            int LA63_0 = input.LA(1);

            if ( (LA63_0==120) ) {
                alt63=1;
            }
            switch (alt63) {
                case 1 :
                    // InternalMickeyLang.g:6643:3: rule__PrimaryExpression__NotAssignment_5_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__NotAssignment_5_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNotAssignment_5_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_5__2"
    // InternalMickeyLang.g:6651:1: rule__PrimaryExpression__Group_5__2 : rule__PrimaryExpression__Group_5__2__Impl rule__PrimaryExpression__Group_5__3 ;
    public final void rule__PrimaryExpression__Group_5__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6655:1: ( rule__PrimaryExpression__Group_5__2__Impl rule__PrimaryExpression__Group_5__3 )
            // InternalMickeyLang.g:6656:2: rule__PrimaryExpression__Group_5__2__Impl rule__PrimaryExpression__Group_5__3
            {
            pushFollow(FOLLOW_53);
            rule__PrimaryExpression__Group_5__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_5__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__2"


    // $ANTLR start "rule__PrimaryExpression__Group_5__2__Impl"
    // InternalMickeyLang.g:6663:1: rule__PrimaryExpression__Group_5__2__Impl : ( ( rule__PrimaryExpression__ExistsAssignment_5_2 )? ) ;
    public final void rule__PrimaryExpression__Group_5__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6667:1: ( ( ( rule__PrimaryExpression__ExistsAssignment_5_2 )? ) )
            // InternalMickeyLang.g:6668:1: ( ( rule__PrimaryExpression__ExistsAssignment_5_2 )? )
            {
            // InternalMickeyLang.g:6668:1: ( ( rule__PrimaryExpression__ExistsAssignment_5_2 )? )
            // InternalMickeyLang.g:6669:2: ( rule__PrimaryExpression__ExistsAssignment_5_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExistsAssignment_5_2()); 
            }
            // InternalMickeyLang.g:6670:2: ( rule__PrimaryExpression__ExistsAssignment_5_2 )?
            int alt64=2;
            int LA64_0 = input.LA(1);

            if ( (LA64_0==121) ) {
                alt64=1;
            }
            switch (alt64) {
                case 1 :
                    // InternalMickeyLang.g:6670:3: rule__PrimaryExpression__ExistsAssignment_5_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__ExistsAssignment_5_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExistsAssignment_5_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_5__3"
    // InternalMickeyLang.g:6678:1: rule__PrimaryExpression__Group_5__3 : rule__PrimaryExpression__Group_5__3__Impl rule__PrimaryExpression__Group_5__4 ;
    public final void rule__PrimaryExpression__Group_5__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6682:1: ( rule__PrimaryExpression__Group_5__3__Impl rule__PrimaryExpression__Group_5__4 )
            // InternalMickeyLang.g:6683:2: rule__PrimaryExpression__Group_5__3__Impl rule__PrimaryExpression__Group_5__4
            {
            pushFollow(FOLLOW_54);
            rule__PrimaryExpression__Group_5__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_5__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__3"


    // $ANTLR start "rule__PrimaryExpression__Group_5__3__Impl"
    // InternalMickeyLang.g:6690:1: rule__PrimaryExpression__Group_5__3__Impl : ( '(' ) ;
    public final void rule__PrimaryExpression__Group_5__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6694:1: ( ( '(' ) )
            // InternalMickeyLang.g:6695:1: ( '(' )
            {
            // InternalMickeyLang.g:6695:1: ( '(' )
            // InternalMickeyLang.g:6696:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_5_3()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_5_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__3__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_5__4"
    // InternalMickeyLang.g:6705:1: rule__PrimaryExpression__Group_5__4 : rule__PrimaryExpression__Group_5__4__Impl rule__PrimaryExpression__Group_5__5 ;
    public final void rule__PrimaryExpression__Group_5__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6709:1: ( rule__PrimaryExpression__Group_5__4__Impl rule__PrimaryExpression__Group_5__5 )
            // InternalMickeyLang.g:6710:2: rule__PrimaryExpression__Group_5__4__Impl rule__PrimaryExpression__Group_5__5
            {
            pushFollow(FOLLOW_52);
            rule__PrimaryExpression__Group_5__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_5__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__4"


    // $ANTLR start "rule__PrimaryExpression__Group_5__4__Impl"
    // InternalMickeyLang.g:6717:1: rule__PrimaryExpression__Group_5__4__Impl : ( ( rule__PrimaryExpression__SelectAssignment_5_4 ) ) ;
    public final void rule__PrimaryExpression__Group_5__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6721:1: ( ( ( rule__PrimaryExpression__SelectAssignment_5_4 ) ) )
            // InternalMickeyLang.g:6722:1: ( ( rule__PrimaryExpression__SelectAssignment_5_4 ) )
            {
            // InternalMickeyLang.g:6722:1: ( ( rule__PrimaryExpression__SelectAssignment_5_4 ) )
            // InternalMickeyLang.g:6723:2: ( rule__PrimaryExpression__SelectAssignment_5_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSelectAssignment_5_4()); 
            }
            // InternalMickeyLang.g:6724:2: ( rule__PrimaryExpression__SelectAssignment_5_4 )
            // InternalMickeyLang.g:6724:3: rule__PrimaryExpression__SelectAssignment_5_4
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__SelectAssignment_5_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSelectAssignment_5_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__4__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_5__5"
    // InternalMickeyLang.g:6732:1: rule__PrimaryExpression__Group_5__5 : rule__PrimaryExpression__Group_5__5__Impl ;
    public final void rule__PrimaryExpression__Group_5__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6736:1: ( rule__PrimaryExpression__Group_5__5__Impl )
            // InternalMickeyLang.g:6737:2: rule__PrimaryExpression__Group_5__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_5__5__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__5"


    // $ANTLR start "rule__PrimaryExpression__Group_5__5__Impl"
    // InternalMickeyLang.g:6743:1: rule__PrimaryExpression__Group_5__5__Impl : ( ')' ) ;
    public final void rule__PrimaryExpression__Group_5__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6747:1: ( ( ')' ) )
            // InternalMickeyLang.g:6748:1: ( ')' )
            {
            // InternalMickeyLang.g:6748:1: ( ')' )
            // InternalMickeyLang.g:6749:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_5_5()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_5_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_5__5__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6__0"
    // InternalMickeyLang.g:6759:1: rule__PrimaryExpression__Group_6__0 : rule__PrimaryExpression__Group_6__0__Impl rule__PrimaryExpression__Group_6__1 ;
    public final void rule__PrimaryExpression__Group_6__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6763:1: ( rule__PrimaryExpression__Group_6__0__Impl rule__PrimaryExpression__Group_6__1 )
            // InternalMickeyLang.g:6764:2: rule__PrimaryExpression__Group_6__0__Impl rule__PrimaryExpression__Group_6__1
            {
            pushFollow(FOLLOW_55);
            rule__PrimaryExpression__Group_6__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__0"


    // $ANTLR start "rule__PrimaryExpression__Group_6__0__Impl"
    // InternalMickeyLang.g:6771:1: rule__PrimaryExpression__Group_6__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_6__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6775:1: ( ( () ) )
            // InternalMickeyLang.g:6776:1: ( () )
            {
            // InternalMickeyLang.g:6776:1: ( () )
            // InternalMickeyLang.g:6777:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCaseExpressionAction_6_0()); 
            }
            // InternalMickeyLang.g:6778:2: ()
            // InternalMickeyLang.g:6778:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCaseExpressionAction_6_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6__1"
    // InternalMickeyLang.g:6786:1: rule__PrimaryExpression__Group_6__1 : rule__PrimaryExpression__Group_6__1__Impl rule__PrimaryExpression__Group_6__2 ;
    public final void rule__PrimaryExpression__Group_6__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6790:1: ( rule__PrimaryExpression__Group_6__1__Impl rule__PrimaryExpression__Group_6__2 )
            // InternalMickeyLang.g:6791:2: rule__PrimaryExpression__Group_6__1__Impl rule__PrimaryExpression__Group_6__2
            {
            pushFollow(FOLLOW_56);
            rule__PrimaryExpression__Group_6__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__1"


    // $ANTLR start "rule__PrimaryExpression__Group_6__1__Impl"
    // InternalMickeyLang.g:6798:1: rule__PrimaryExpression__Group_6__1__Impl : ( 'case' ) ;
    public final void rule__PrimaryExpression__Group_6__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6802:1: ( ( 'case' ) )
            // InternalMickeyLang.g:6803:1: ( 'case' )
            {
            // InternalMickeyLang.g:6803:1: ( 'case' )
            // InternalMickeyLang.g:6804:2: 'case'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCaseKeyword_6_1()); 
            }
            match(input,78,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCaseKeyword_6_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6__2"
    // InternalMickeyLang.g:6813:1: rule__PrimaryExpression__Group_6__2 : rule__PrimaryExpression__Group_6__2__Impl rule__PrimaryExpression__Group_6__3 ;
    public final void rule__PrimaryExpression__Group_6__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6817:1: ( rule__PrimaryExpression__Group_6__2__Impl rule__PrimaryExpression__Group_6__3 )
            // InternalMickeyLang.g:6818:2: rule__PrimaryExpression__Group_6__2__Impl rule__PrimaryExpression__Group_6__3
            {
            pushFollow(FOLLOW_56);
            rule__PrimaryExpression__Group_6__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__2"


    // $ANTLR start "rule__PrimaryExpression__Group_6__2__Impl"
    // InternalMickeyLang.g:6825:1: rule__PrimaryExpression__Group_6__2__Impl : ( ( rule__PrimaryExpression__CaseExpressionAssignment_6_2 )? ) ;
    public final void rule__PrimaryExpression__Group_6__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6829:1: ( ( ( rule__PrimaryExpression__CaseExpressionAssignment_6_2 )? ) )
            // InternalMickeyLang.g:6830:1: ( ( rule__PrimaryExpression__CaseExpressionAssignment_6_2 )? )
            {
            // InternalMickeyLang.g:6830:1: ( ( rule__PrimaryExpression__CaseExpressionAssignment_6_2 )? )
            // InternalMickeyLang.g:6831:2: ( rule__PrimaryExpression__CaseExpressionAssignment_6_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCaseExpressionAssignment_6_2()); 
            }
            // InternalMickeyLang.g:6832:2: ( rule__PrimaryExpression__CaseExpressionAssignment_6_2 )?
            int alt65=2;
            int LA65_0 = input.LA(1);

            if ( ((LA65_0>=RULE_NUMBER && LA65_0<=RULE_STRING)||LA65_0==16||LA65_0==62||(LA65_0>=75 && LA65_0<=76)||LA65_0==78||LA65_0==81||LA65_0==83||(LA65_0>=120 && LA65_0<=121)||(LA65_0>=131 && LA65_0<=134)) ) {
                alt65=1;
            }
            switch (alt65) {
                case 1 :
                    // InternalMickeyLang.g:6832:3: rule__PrimaryExpression__CaseExpressionAssignment_6_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__CaseExpressionAssignment_6_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCaseExpressionAssignment_6_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6__3"
    // InternalMickeyLang.g:6840:1: rule__PrimaryExpression__Group_6__3 : rule__PrimaryExpression__Group_6__3__Impl rule__PrimaryExpression__Group_6__4 ;
    public final void rule__PrimaryExpression__Group_6__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6844:1: ( rule__PrimaryExpression__Group_6__3__Impl rule__PrimaryExpression__Group_6__4 )
            // InternalMickeyLang.g:6845:2: rule__PrimaryExpression__Group_6__3__Impl rule__PrimaryExpression__Group_6__4
            {
            pushFollow(FOLLOW_57);
            rule__PrimaryExpression__Group_6__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__3"


    // $ANTLR start "rule__PrimaryExpression__Group_6__3__Impl"
    // InternalMickeyLang.g:6852:1: rule__PrimaryExpression__Group_6__3__Impl : ( ( ( rule__PrimaryExpression__CasesAssignment_6_3 ) ) ( ( rule__PrimaryExpression__CasesAssignment_6_3 )* ) ) ;
    public final void rule__PrimaryExpression__Group_6__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6856:1: ( ( ( ( rule__PrimaryExpression__CasesAssignment_6_3 ) ) ( ( rule__PrimaryExpression__CasesAssignment_6_3 )* ) ) )
            // InternalMickeyLang.g:6857:1: ( ( ( rule__PrimaryExpression__CasesAssignment_6_3 ) ) ( ( rule__PrimaryExpression__CasesAssignment_6_3 )* ) )
            {
            // InternalMickeyLang.g:6857:1: ( ( ( rule__PrimaryExpression__CasesAssignment_6_3 ) ) ( ( rule__PrimaryExpression__CasesAssignment_6_3 )* ) )
            // InternalMickeyLang.g:6858:2: ( ( rule__PrimaryExpression__CasesAssignment_6_3 ) ) ( ( rule__PrimaryExpression__CasesAssignment_6_3 )* )
            {
            // InternalMickeyLang.g:6858:2: ( ( rule__PrimaryExpression__CasesAssignment_6_3 ) )
            // InternalMickeyLang.g:6859:3: ( rule__PrimaryExpression__CasesAssignment_6_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_6_3()); 
            }
            // InternalMickeyLang.g:6860:3: ( rule__PrimaryExpression__CasesAssignment_6_3 )
            // InternalMickeyLang.g:6860:4: rule__PrimaryExpression__CasesAssignment_6_3
            {
            pushFollow(FOLLOW_58);
            rule__PrimaryExpression__CasesAssignment_6_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_6_3()); 
            }

            }

            // InternalMickeyLang.g:6863:2: ( ( rule__PrimaryExpression__CasesAssignment_6_3 )* )
            // InternalMickeyLang.g:6864:3: ( rule__PrimaryExpression__CasesAssignment_6_3 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_6_3()); 
            }
            // InternalMickeyLang.g:6865:3: ( rule__PrimaryExpression__CasesAssignment_6_3 )*
            loop66:
            do {
                int alt66=2;
                int LA66_0 = input.LA(1);

                if ( (LA66_0==84) ) {
                    alt66=1;
                }


                switch (alt66) {
            	case 1 :
            	    // InternalMickeyLang.g:6865:4: rule__PrimaryExpression__CasesAssignment_6_3
            	    {
            	    pushFollow(FOLLOW_58);
            	    rule__PrimaryExpression__CasesAssignment_6_3();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop66;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCasesAssignment_6_3()); 
            }

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__3__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6__4"
    // InternalMickeyLang.g:6874:1: rule__PrimaryExpression__Group_6__4 : rule__PrimaryExpression__Group_6__4__Impl rule__PrimaryExpression__Group_6__5 ;
    public final void rule__PrimaryExpression__Group_6__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6878:1: ( rule__PrimaryExpression__Group_6__4__Impl rule__PrimaryExpression__Group_6__5 )
            // InternalMickeyLang.g:6879:2: rule__PrimaryExpression__Group_6__4__Impl rule__PrimaryExpression__Group_6__5
            {
            pushFollow(FOLLOW_57);
            rule__PrimaryExpression__Group_6__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__4"


    // $ANTLR start "rule__PrimaryExpression__Group_6__4__Impl"
    // InternalMickeyLang.g:6886:1: rule__PrimaryExpression__Group_6__4__Impl : ( ( rule__PrimaryExpression__Group_6_4__0 )? ) ;
    public final void rule__PrimaryExpression__Group_6__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6890:1: ( ( ( rule__PrimaryExpression__Group_6_4__0 )? ) )
            // InternalMickeyLang.g:6891:1: ( ( rule__PrimaryExpression__Group_6_4__0 )? )
            {
            // InternalMickeyLang.g:6891:1: ( ( rule__PrimaryExpression__Group_6_4__0 )? )
            // InternalMickeyLang.g:6892:2: ( rule__PrimaryExpression__Group_6_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getGroup_6_4()); 
            }
            // InternalMickeyLang.g:6893:2: ( rule__PrimaryExpression__Group_6_4__0 )?
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==80) ) {
                alt67=1;
            }
            switch (alt67) {
                case 1 :
                    // InternalMickeyLang.g:6893:3: rule__PrimaryExpression__Group_6_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryExpression__Group_6_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getGroup_6_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__4__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6__5"
    // InternalMickeyLang.g:6901:1: rule__PrimaryExpression__Group_6__5 : rule__PrimaryExpression__Group_6__5__Impl ;
    public final void rule__PrimaryExpression__Group_6__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6905:1: ( rule__PrimaryExpression__Group_6__5__Impl )
            // InternalMickeyLang.g:6906:2: rule__PrimaryExpression__Group_6__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6__5__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__5"


    // $ANTLR start "rule__PrimaryExpression__Group_6__5__Impl"
    // InternalMickeyLang.g:6912:1: rule__PrimaryExpression__Group_6__5__Impl : ( 'end' ) ;
    public final void rule__PrimaryExpression__Group_6__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6916:1: ( ( 'end' ) )
            // InternalMickeyLang.g:6917:1: ( 'end' )
            {
            // InternalMickeyLang.g:6917:1: ( 'end' )
            // InternalMickeyLang.g:6918:2: 'end'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getEndKeyword_6_5()); 
            }
            match(input,79,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getEndKeyword_6_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6__5__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6_4__0"
    // InternalMickeyLang.g:6928:1: rule__PrimaryExpression__Group_6_4__0 : rule__PrimaryExpression__Group_6_4__0__Impl rule__PrimaryExpression__Group_6_4__1 ;
    public final void rule__PrimaryExpression__Group_6_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6932:1: ( rule__PrimaryExpression__Group_6_4__0__Impl rule__PrimaryExpression__Group_6_4__1 )
            // InternalMickeyLang.g:6933:2: rule__PrimaryExpression__Group_6_4__0__Impl rule__PrimaryExpression__Group_6_4__1
            {
            pushFollow(FOLLOW_30);
            rule__PrimaryExpression__Group_6_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6_4__0"


    // $ANTLR start "rule__PrimaryExpression__Group_6_4__0__Impl"
    // InternalMickeyLang.g:6940:1: rule__PrimaryExpression__Group_6_4__0__Impl : ( 'else' ) ;
    public final void rule__PrimaryExpression__Group_6_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6944:1: ( ( 'else' ) )
            // InternalMickeyLang.g:6945:1: ( 'else' )
            {
            // InternalMickeyLang.g:6945:1: ( 'else' )
            // InternalMickeyLang.g:6946:2: 'else'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getElseKeyword_6_4_0()); 
            }
            match(input,80,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getElseKeyword_6_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6_4__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_6_4__1"
    // InternalMickeyLang.g:6955:1: rule__PrimaryExpression__Group_6_4__1 : rule__PrimaryExpression__Group_6_4__1__Impl ;
    public final void rule__PrimaryExpression__Group_6_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6959:1: ( rule__PrimaryExpression__Group_6_4__1__Impl )
            // InternalMickeyLang.g:6960:2: rule__PrimaryExpression__Group_6_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_6_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6_4__1"


    // $ANTLR start "rule__PrimaryExpression__Group_6_4__1__Impl"
    // InternalMickeyLang.g:6966:1: rule__PrimaryExpression__Group_6_4__1__Impl : ( ( rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 ) ) ;
    public final void rule__PrimaryExpression__Group_6_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6970:1: ( ( ( rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 ) ) )
            // InternalMickeyLang.g:6971:1: ( ( rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 ) )
            {
            // InternalMickeyLang.g:6971:1: ( ( rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 ) )
            // InternalMickeyLang.g:6972:2: ( rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getElseExpressionAssignment_6_4_1()); 
            }
            // InternalMickeyLang.g:6973:2: ( rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 )
            // InternalMickeyLang.g:6973:3: rule__PrimaryExpression__ElseExpressionAssignment_6_4_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ElseExpressionAssignment_6_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getElseExpressionAssignment_6_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_6_4__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7__0"
    // InternalMickeyLang.g:6982:1: rule__PrimaryExpression__Group_7__0 : rule__PrimaryExpression__Group_7__0__Impl rule__PrimaryExpression__Group_7__1 ;
    public final void rule__PrimaryExpression__Group_7__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6986:1: ( rule__PrimaryExpression__Group_7__0__Impl rule__PrimaryExpression__Group_7__1 )
            // InternalMickeyLang.g:6987:2: rule__PrimaryExpression__Group_7__0__Impl rule__PrimaryExpression__Group_7__1
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryExpression__Group_7__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__0"


    // $ANTLR start "rule__PrimaryExpression__Group_7__0__Impl"
    // InternalMickeyLang.g:6994:1: rule__PrimaryExpression__Group_7__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_7__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:6998:1: ( ( () ) )
            // InternalMickeyLang.g:6999:1: ( () )
            {
            // InternalMickeyLang.g:6999:1: ( () )
            // InternalMickeyLang.g:7000:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getFunctionAction_7_0()); 
            }
            // InternalMickeyLang.g:7001:2: ()
            // InternalMickeyLang.g:7001:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getFunctionAction_7_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7__1"
    // InternalMickeyLang.g:7009:1: rule__PrimaryExpression__Group_7__1 : rule__PrimaryExpression__Group_7__1__Impl rule__PrimaryExpression__Group_7__2 ;
    public final void rule__PrimaryExpression__Group_7__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7013:1: ( rule__PrimaryExpression__Group_7__1__Impl rule__PrimaryExpression__Group_7__2 )
            // InternalMickeyLang.g:7014:2: rule__PrimaryExpression__Group_7__1__Impl rule__PrimaryExpression__Group_7__2
            {
            pushFollow(FOLLOW_6);
            rule__PrimaryExpression__Group_7__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__1"


    // $ANTLR start "rule__PrimaryExpression__Group_7__1__Impl"
    // InternalMickeyLang.g:7021:1: rule__PrimaryExpression__Group_7__1__Impl : ( ( rule__PrimaryExpression__NameAssignment_7_1 ) ) ;
    public final void rule__PrimaryExpression__Group_7__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7025:1: ( ( ( rule__PrimaryExpression__NameAssignment_7_1 ) ) )
            // InternalMickeyLang.g:7026:1: ( ( rule__PrimaryExpression__NameAssignment_7_1 ) )
            {
            // InternalMickeyLang.g:7026:1: ( ( rule__PrimaryExpression__NameAssignment_7_1 ) )
            // InternalMickeyLang.g:7027:2: ( rule__PrimaryExpression__NameAssignment_7_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNameAssignment_7_1()); 
            }
            // InternalMickeyLang.g:7028:2: ( rule__PrimaryExpression__NameAssignment_7_1 )
            // InternalMickeyLang.g:7028:3: rule__PrimaryExpression__NameAssignment_7_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__NameAssignment_7_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNameAssignment_7_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7__2"
    // InternalMickeyLang.g:7036:1: rule__PrimaryExpression__Group_7__2 : rule__PrimaryExpression__Group_7__2__Impl rule__PrimaryExpression__Group_7__3 ;
    public final void rule__PrimaryExpression__Group_7__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7040:1: ( rule__PrimaryExpression__Group_7__2__Impl rule__PrimaryExpression__Group_7__3 )
            // InternalMickeyLang.g:7041:2: rule__PrimaryExpression__Group_7__2__Impl rule__PrimaryExpression__Group_7__3
            {
            pushFollow(FOLLOW_59);
            rule__PrimaryExpression__Group_7__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__2"


    // $ANTLR start "rule__PrimaryExpression__Group_7__2__Impl"
    // InternalMickeyLang.g:7048:1: rule__PrimaryExpression__Group_7__2__Impl : ( '(' ) ;
    public final void rule__PrimaryExpression__Group_7__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7052:1: ( ( '(' ) )
            // InternalMickeyLang.g:7053:1: ( '(' )
            {
            // InternalMickeyLang.g:7053:1: ( '(' )
            // InternalMickeyLang.g:7054:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_7_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_7_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7__3"
    // InternalMickeyLang.g:7063:1: rule__PrimaryExpression__Group_7__3 : rule__PrimaryExpression__Group_7__3__Impl rule__PrimaryExpression__Group_7__4 ;
    public final void rule__PrimaryExpression__Group_7__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7067:1: ( rule__PrimaryExpression__Group_7__3__Impl rule__PrimaryExpression__Group_7__4 )
            // InternalMickeyLang.g:7068:2: rule__PrimaryExpression__Group_7__3__Impl rule__PrimaryExpression__Group_7__4
            {
            pushFollow(FOLLOW_52);
            rule__PrimaryExpression__Group_7__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__3"


    // $ANTLR start "rule__PrimaryExpression__Group_7__3__Impl"
    // InternalMickeyLang.g:7075:1: rule__PrimaryExpression__Group_7__3__Impl : ( ( rule__PrimaryExpression__Alternatives_7_3 ) ) ;
    public final void rule__PrimaryExpression__Group_7__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7079:1: ( ( ( rule__PrimaryExpression__Alternatives_7_3 ) ) )
            // InternalMickeyLang.g:7080:1: ( ( rule__PrimaryExpression__Alternatives_7_3 ) )
            {
            // InternalMickeyLang.g:7080:1: ( ( rule__PrimaryExpression__Alternatives_7_3 ) )
            // InternalMickeyLang.g:7081:2: ( rule__PrimaryExpression__Alternatives_7_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAlternatives_7_3()); 
            }
            // InternalMickeyLang.g:7082:2: ( rule__PrimaryExpression__Alternatives_7_3 )
            // InternalMickeyLang.g:7082:3: rule__PrimaryExpression__Alternatives_7_3
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Alternatives_7_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAlternatives_7_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__3__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7__4"
    // InternalMickeyLang.g:7090:1: rule__PrimaryExpression__Group_7__4 : rule__PrimaryExpression__Group_7__4__Impl ;
    public final void rule__PrimaryExpression__Group_7__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7094:1: ( rule__PrimaryExpression__Group_7__4__Impl )
            // InternalMickeyLang.g:7095:2: rule__PrimaryExpression__Group_7__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__4"


    // $ANTLR start "rule__PrimaryExpression__Group_7__4__Impl"
    // InternalMickeyLang.g:7101:1: rule__PrimaryExpression__Group_7__4__Impl : ( ')' ) ;
    public final void rule__PrimaryExpression__Group_7__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7105:1: ( ( ')' ) )
            // InternalMickeyLang.g:7106:1: ( ')' )
            {
            // InternalMickeyLang.g:7106:1: ( ')' )
            // InternalMickeyLang.g:7107:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_7_4()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_7_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7__4__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1__0"
    // InternalMickeyLang.g:7117:1: rule__PrimaryExpression__Group_7_3_1__0 : rule__PrimaryExpression__Group_7_3_1__0__Impl rule__PrimaryExpression__Group_7_3_1__1 ;
    public final void rule__PrimaryExpression__Group_7_3_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7121:1: ( rule__PrimaryExpression__Group_7_3_1__0__Impl rule__PrimaryExpression__Group_7_3_1__1 )
            // InternalMickeyLang.g:7122:2: rule__PrimaryExpression__Group_7_3_1__0__Impl rule__PrimaryExpression__Group_7_3_1__1
            {
            pushFollow(FOLLOW_11);
            rule__PrimaryExpression__Group_7_3_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7_3_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1__0"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1__0__Impl"
    // InternalMickeyLang.g:7129:1: rule__PrimaryExpression__Group_7_3_1__0__Impl : ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 ) ) ;
    public final void rule__PrimaryExpression__Group_7_3_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7133:1: ( ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 ) ) )
            // InternalMickeyLang.g:7134:1: ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 ) )
            {
            // InternalMickeyLang.g:7134:1: ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 ) )
            // InternalMickeyLang.g:7135:2: ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgumentsAssignment_7_3_1_0()); 
            }
            // InternalMickeyLang.g:7136:2: ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 )
            // InternalMickeyLang.g:7136:3: rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgumentsAssignment_7_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1__1"
    // InternalMickeyLang.g:7144:1: rule__PrimaryExpression__Group_7_3_1__1 : rule__PrimaryExpression__Group_7_3_1__1__Impl ;
    public final void rule__PrimaryExpression__Group_7_3_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7148:1: ( rule__PrimaryExpression__Group_7_3_1__1__Impl )
            // InternalMickeyLang.g:7149:2: rule__PrimaryExpression__Group_7_3_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7_3_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1__1"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1__1__Impl"
    // InternalMickeyLang.g:7155:1: rule__PrimaryExpression__Group_7_3_1__1__Impl : ( ( rule__PrimaryExpression__Group_7_3_1_1__0 )* ) ;
    public final void rule__PrimaryExpression__Group_7_3_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7159:1: ( ( ( rule__PrimaryExpression__Group_7_3_1_1__0 )* ) )
            // InternalMickeyLang.g:7160:1: ( ( rule__PrimaryExpression__Group_7_3_1_1__0 )* )
            {
            // InternalMickeyLang.g:7160:1: ( ( rule__PrimaryExpression__Group_7_3_1_1__0 )* )
            // InternalMickeyLang.g:7161:2: ( rule__PrimaryExpression__Group_7_3_1_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getGroup_7_3_1_1()); 
            }
            // InternalMickeyLang.g:7162:2: ( rule__PrimaryExpression__Group_7_3_1_1__0 )*
            loop68:
            do {
                int alt68=2;
                int LA68_0 = input.LA(1);

                if ( (LA68_0==40) ) {
                    alt68=1;
                }


                switch (alt68) {
            	case 1 :
            	    // InternalMickeyLang.g:7162:3: rule__PrimaryExpression__Group_7_3_1_1__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__PrimaryExpression__Group_7_3_1_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop68;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getGroup_7_3_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1_1__0"
    // InternalMickeyLang.g:7171:1: rule__PrimaryExpression__Group_7_3_1_1__0 : rule__PrimaryExpression__Group_7_3_1_1__0__Impl rule__PrimaryExpression__Group_7_3_1_1__1 ;
    public final void rule__PrimaryExpression__Group_7_3_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7175:1: ( rule__PrimaryExpression__Group_7_3_1_1__0__Impl rule__PrimaryExpression__Group_7_3_1_1__1 )
            // InternalMickeyLang.g:7176:2: rule__PrimaryExpression__Group_7_3_1_1__0__Impl rule__PrimaryExpression__Group_7_3_1_1__1
            {
            pushFollow(FOLLOW_30);
            rule__PrimaryExpression__Group_7_3_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7_3_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1_1__0"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1_1__0__Impl"
    // InternalMickeyLang.g:7183:1: rule__PrimaryExpression__Group_7_3_1_1__0__Impl : ( ',' ) ;
    public final void rule__PrimaryExpression__Group_7_3_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7187:1: ( ( ',' ) )
            // InternalMickeyLang.g:7188:1: ( ',' )
            {
            // InternalMickeyLang.g:7188:1: ( ',' )
            // InternalMickeyLang.g:7189:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCommaKeyword_7_3_1_1_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCommaKeyword_7_3_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1_1__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1_1__1"
    // InternalMickeyLang.g:7198:1: rule__PrimaryExpression__Group_7_3_1_1__1 : rule__PrimaryExpression__Group_7_3_1_1__1__Impl ;
    public final void rule__PrimaryExpression__Group_7_3_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7202:1: ( rule__PrimaryExpression__Group_7_3_1_1__1__Impl )
            // InternalMickeyLang.g:7203:2: rule__PrimaryExpression__Group_7_3_1_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_7_3_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1_1__1"


    // $ANTLR start "rule__PrimaryExpression__Group_7_3_1_1__1__Impl"
    // InternalMickeyLang.g:7209:1: rule__PrimaryExpression__Group_7_3_1_1__1__Impl : ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 ) ) ;
    public final void rule__PrimaryExpression__Group_7_3_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7213:1: ( ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 ) ) )
            // InternalMickeyLang.g:7214:1: ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 ) )
            {
            // InternalMickeyLang.g:7214:1: ( ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 ) )
            // InternalMickeyLang.g:7215:2: ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgumentsAssignment_7_3_1_1_1()); 
            }
            // InternalMickeyLang.g:7216:2: ( rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 )
            // InternalMickeyLang.g:7216:3: rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgumentsAssignment_7_3_1_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_7_3_1_1__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__0"
    // InternalMickeyLang.g:7225:1: rule__PrimaryExpression__Group_8__0 : rule__PrimaryExpression__Group_8__0__Impl rule__PrimaryExpression__Group_8__1 ;
    public final void rule__PrimaryExpression__Group_8__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7229:1: ( rule__PrimaryExpression__Group_8__0__Impl rule__PrimaryExpression__Group_8__1 )
            // InternalMickeyLang.g:7230:2: rule__PrimaryExpression__Group_8__0__Impl rule__PrimaryExpression__Group_8__1
            {
            pushFollow(FOLLOW_60);
            rule__PrimaryExpression__Group_8__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__0"


    // $ANTLR start "rule__PrimaryExpression__Group_8__0__Impl"
    // InternalMickeyLang.g:7237:1: rule__PrimaryExpression__Group_8__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_8__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7241:1: ( ( () ) )
            // InternalMickeyLang.g:7242:1: ( () )
            {
            // InternalMickeyLang.g:7242:1: ( () )
            // InternalMickeyLang.g:7243:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCastExpressionAction_8_0()); 
            }
            // InternalMickeyLang.g:7244:2: ()
            // InternalMickeyLang.g:7244:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCastExpressionAction_8_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__1"
    // InternalMickeyLang.g:7252:1: rule__PrimaryExpression__Group_8__1 : rule__PrimaryExpression__Group_8__1__Impl rule__PrimaryExpression__Group_8__2 ;
    public final void rule__PrimaryExpression__Group_8__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7256:1: ( rule__PrimaryExpression__Group_8__1__Impl rule__PrimaryExpression__Group_8__2 )
            // InternalMickeyLang.g:7257:2: rule__PrimaryExpression__Group_8__1__Impl rule__PrimaryExpression__Group_8__2
            {
            pushFollow(FOLLOW_6);
            rule__PrimaryExpression__Group_8__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__1"


    // $ANTLR start "rule__PrimaryExpression__Group_8__1__Impl"
    // InternalMickeyLang.g:7264:1: rule__PrimaryExpression__Group_8__1__Impl : ( 'cast' ) ;
    public final void rule__PrimaryExpression__Group_8__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7268:1: ( ( 'cast' ) )
            // InternalMickeyLang.g:7269:1: ( 'cast' )
            {
            // InternalMickeyLang.g:7269:1: ( 'cast' )
            // InternalMickeyLang.g:7270:2: 'cast'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCastKeyword_8_1()); 
            }
            match(input,81,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCastKeyword_8_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__2"
    // InternalMickeyLang.g:7279:1: rule__PrimaryExpression__Group_8__2 : rule__PrimaryExpression__Group_8__2__Impl rule__PrimaryExpression__Group_8__3 ;
    public final void rule__PrimaryExpression__Group_8__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7283:1: ( rule__PrimaryExpression__Group_8__2__Impl rule__PrimaryExpression__Group_8__3 )
            // InternalMickeyLang.g:7284:2: rule__PrimaryExpression__Group_8__2__Impl rule__PrimaryExpression__Group_8__3
            {
            pushFollow(FOLLOW_30);
            rule__PrimaryExpression__Group_8__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__2"


    // $ANTLR start "rule__PrimaryExpression__Group_8__2__Impl"
    // InternalMickeyLang.g:7291:1: rule__PrimaryExpression__Group_8__2__Impl : ( '(' ) ;
    public final void rule__PrimaryExpression__Group_8__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7295:1: ( ( '(' ) )
            // InternalMickeyLang.g:7296:1: ( '(' )
            {
            // InternalMickeyLang.g:7296:1: ( '(' )
            // InternalMickeyLang.g:7297:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_8_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_8_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__2__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__3"
    // InternalMickeyLang.g:7306:1: rule__PrimaryExpression__Group_8__3 : rule__PrimaryExpression__Group_8__3__Impl rule__PrimaryExpression__Group_8__4 ;
    public final void rule__PrimaryExpression__Group_8__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7310:1: ( rule__PrimaryExpression__Group_8__3__Impl rule__PrimaryExpression__Group_8__4 )
            // InternalMickeyLang.g:7311:2: rule__PrimaryExpression__Group_8__3__Impl rule__PrimaryExpression__Group_8__4
            {
            pushFollow(FOLLOW_61);
            rule__PrimaryExpression__Group_8__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__3"


    // $ANTLR start "rule__PrimaryExpression__Group_8__3__Impl"
    // InternalMickeyLang.g:7318:1: rule__PrimaryExpression__Group_8__3__Impl : ( ( rule__PrimaryExpression__ExpressionAssignment_8_3 ) ) ;
    public final void rule__PrimaryExpression__Group_8__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7322:1: ( ( ( rule__PrimaryExpression__ExpressionAssignment_8_3 ) ) )
            // InternalMickeyLang.g:7323:1: ( ( rule__PrimaryExpression__ExpressionAssignment_8_3 ) )
            {
            // InternalMickeyLang.g:7323:1: ( ( rule__PrimaryExpression__ExpressionAssignment_8_3 ) )
            // InternalMickeyLang.g:7324:2: ( rule__PrimaryExpression__ExpressionAssignment_8_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExpressionAssignment_8_3()); 
            }
            // InternalMickeyLang.g:7325:2: ( rule__PrimaryExpression__ExpressionAssignment_8_3 )
            // InternalMickeyLang.g:7325:3: rule__PrimaryExpression__ExpressionAssignment_8_3
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ExpressionAssignment_8_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExpressionAssignment_8_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__3__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__4"
    // InternalMickeyLang.g:7333:1: rule__PrimaryExpression__Group_8__4 : rule__PrimaryExpression__Group_8__4__Impl rule__PrimaryExpression__Group_8__5 ;
    public final void rule__PrimaryExpression__Group_8__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7337:1: ( rule__PrimaryExpression__Group_8__4__Impl rule__PrimaryExpression__Group_8__5 )
            // InternalMickeyLang.g:7338:2: rule__PrimaryExpression__Group_8__4__Impl rule__PrimaryExpression__Group_8__5
            {
            pushFollow(FOLLOW_62);
            rule__PrimaryExpression__Group_8__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__4"


    // $ANTLR start "rule__PrimaryExpression__Group_8__4__Impl"
    // InternalMickeyLang.g:7345:1: rule__PrimaryExpression__Group_8__4__Impl : ( 'as' ) ;
    public final void rule__PrimaryExpression__Group_8__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7349:1: ( ( 'as' ) )
            // InternalMickeyLang.g:7350:1: ( 'as' )
            {
            // InternalMickeyLang.g:7350:1: ( 'as' )
            // InternalMickeyLang.g:7351:2: 'as'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAsKeyword_8_4()); 
            }
            match(input,82,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAsKeyword_8_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__4__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__5"
    // InternalMickeyLang.g:7360:1: rule__PrimaryExpression__Group_8__5 : rule__PrimaryExpression__Group_8__5__Impl rule__PrimaryExpression__Group_8__6 ;
    public final void rule__PrimaryExpression__Group_8__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7364:1: ( rule__PrimaryExpression__Group_8__5__Impl rule__PrimaryExpression__Group_8__6 )
            // InternalMickeyLang.g:7365:2: rule__PrimaryExpression__Group_8__5__Impl rule__PrimaryExpression__Group_8__6
            {
            pushFollow(FOLLOW_52);
            rule__PrimaryExpression__Group_8__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__5"


    // $ANTLR start "rule__PrimaryExpression__Group_8__5__Impl"
    // InternalMickeyLang.g:7372:1: rule__PrimaryExpression__Group_8__5__Impl : ( ( rule__PrimaryExpression__TypeAssignment_8_5 ) ) ;
    public final void rule__PrimaryExpression__Group_8__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7376:1: ( ( ( rule__PrimaryExpression__TypeAssignment_8_5 ) ) )
            // InternalMickeyLang.g:7377:1: ( ( rule__PrimaryExpression__TypeAssignment_8_5 ) )
            {
            // InternalMickeyLang.g:7377:1: ( ( rule__PrimaryExpression__TypeAssignment_8_5 ) )
            // InternalMickeyLang.g:7378:2: ( rule__PrimaryExpression__TypeAssignment_8_5 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getTypeAssignment_8_5()); 
            }
            // InternalMickeyLang.g:7379:2: ( rule__PrimaryExpression__TypeAssignment_8_5 )
            // InternalMickeyLang.g:7379:3: rule__PrimaryExpression__TypeAssignment_8_5
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__TypeAssignment_8_5();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getTypeAssignment_8_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__5__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_8__6"
    // InternalMickeyLang.g:7387:1: rule__PrimaryExpression__Group_8__6 : rule__PrimaryExpression__Group_8__6__Impl ;
    public final void rule__PrimaryExpression__Group_8__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7391:1: ( rule__PrimaryExpression__Group_8__6__Impl )
            // InternalMickeyLang.g:7392:2: rule__PrimaryExpression__Group_8__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_8__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__6"


    // $ANTLR start "rule__PrimaryExpression__Group_8__6__Impl"
    // InternalMickeyLang.g:7398:1: rule__PrimaryExpression__Group_8__6__Impl : ( ')' ) ;
    public final void rule__PrimaryExpression__Group_8__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7402:1: ( ( ')' ) )
            // InternalMickeyLang.g:7403:1: ( ')' )
            {
            // InternalMickeyLang.g:7403:1: ( ')' )
            // InternalMickeyLang.g:7404:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_8_6()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_8_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_8__6__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_9__0"
    // InternalMickeyLang.g:7414:1: rule__PrimaryExpression__Group_9__0 : rule__PrimaryExpression__Group_9__0__Impl rule__PrimaryExpression__Group_9__1 ;
    public final void rule__PrimaryExpression__Group_9__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7418:1: ( rule__PrimaryExpression__Group_9__0__Impl rule__PrimaryExpression__Group_9__1 )
            // InternalMickeyLang.g:7419:2: rule__PrimaryExpression__Group_9__0__Impl rule__PrimaryExpression__Group_9__1
            {
            pushFollow(FOLLOW_30);
            rule__PrimaryExpression__Group_9__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_9__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_9__0"


    // $ANTLR start "rule__PrimaryExpression__Group_9__0__Impl"
    // InternalMickeyLang.g:7426:1: rule__PrimaryExpression__Group_9__0__Impl : ( () ) ;
    public final void rule__PrimaryExpression__Group_9__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7430:1: ( ( () ) )
            // InternalMickeyLang.g:7431:1: ( () )
            {
            // InternalMickeyLang.g:7431:1: ( () )
            // InternalMickeyLang.g:7432:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getFunctionArgumentAction_9_0()); 
            }
            // InternalMickeyLang.g:7433:2: ()
            // InternalMickeyLang.g:7433:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getFunctionArgumentAction_9_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_9__0__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_9__1"
    // InternalMickeyLang.g:7441:1: rule__PrimaryExpression__Group_9__1 : rule__PrimaryExpression__Group_9__1__Impl rule__PrimaryExpression__Group_9__2 ;
    public final void rule__PrimaryExpression__Group_9__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7445:1: ( rule__PrimaryExpression__Group_9__1__Impl rule__PrimaryExpression__Group_9__2 )
            // InternalMickeyLang.g:7446:2: rule__PrimaryExpression__Group_9__1__Impl rule__PrimaryExpression__Group_9__2
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryExpression__Group_9__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_9__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_9__1"


    // $ANTLR start "rule__PrimaryExpression__Group_9__1__Impl"
    // InternalMickeyLang.g:7453:1: rule__PrimaryExpression__Group_9__1__Impl : ( '$' ) ;
    public final void rule__PrimaryExpression__Group_9__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7457:1: ( ( '$' ) )
            // InternalMickeyLang.g:7458:1: ( '$' )
            {
            // InternalMickeyLang.g:7458:1: ( '$' )
            // InternalMickeyLang.g:7459:2: '$'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getDollarSignKeyword_9_1()); 
            }
            match(input,83,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getDollarSignKeyword_9_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_9__1__Impl"


    // $ANTLR start "rule__PrimaryExpression__Group_9__2"
    // InternalMickeyLang.g:7468:1: rule__PrimaryExpression__Group_9__2 : rule__PrimaryExpression__Group_9__2__Impl ;
    public final void rule__PrimaryExpression__Group_9__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7472:1: ( rule__PrimaryExpression__Group_9__2__Impl )
            // InternalMickeyLang.g:7473:2: rule__PrimaryExpression__Group_9__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__Group_9__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_9__2"


    // $ANTLR start "rule__PrimaryExpression__Group_9__2__Impl"
    // InternalMickeyLang.g:7479:1: rule__PrimaryExpression__Group_9__2__Impl : ( ( rule__PrimaryExpression__ArgAssignment_9_2 ) ) ;
    public final void rule__PrimaryExpression__Group_9__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7483:1: ( ( ( rule__PrimaryExpression__ArgAssignment_9_2 ) ) )
            // InternalMickeyLang.g:7484:1: ( ( rule__PrimaryExpression__ArgAssignment_9_2 ) )
            {
            // InternalMickeyLang.g:7484:1: ( ( rule__PrimaryExpression__ArgAssignment_9_2 ) )
            // InternalMickeyLang.g:7485:2: ( rule__PrimaryExpression__ArgAssignment_9_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgAssignment_9_2()); 
            }
            // InternalMickeyLang.g:7486:2: ( rule__PrimaryExpression__ArgAssignment_9_2 )
            // InternalMickeyLang.g:7486:3: rule__PrimaryExpression__ArgAssignment_9_2
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryExpression__ArgAssignment_9_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgAssignment_9_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__Group_9__2__Impl"


    // $ANTLR start "rule__Case__Group__0"
    // InternalMickeyLang.g:7495:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ;
    public final void rule__Case__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7499:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 )
            // InternalMickeyLang.g:7500:2: rule__Case__Group__0__Impl rule__Case__Group__1
            {
            pushFollow(FOLLOW_30);
            rule__Case__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__Case__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__0"


    // $ANTLR start "rule__Case__Group__0__Impl"
    // InternalMickeyLang.g:7507:1: rule__Case__Group__0__Impl : ( 'when' ) ;
    public final void rule__Case__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7511:1: ( ( 'when' ) )
            // InternalMickeyLang.g:7512:1: ( 'when' )
            {
            // InternalMickeyLang.g:7512:1: ( 'when' )
            // InternalMickeyLang.g:7513:2: 'when'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getWhenKeyword_0()); 
            }
            match(input,84,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getWhenKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__0__Impl"


    // $ANTLR start "rule__Case__Group__1"
    // InternalMickeyLang.g:7522:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ;
    public final void rule__Case__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7526:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 )
            // InternalMickeyLang.g:7527:2: rule__Case__Group__1__Impl rule__Case__Group__2
            {
            pushFollow(FOLLOW_63);
            rule__Case__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__Case__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__1"


    // $ANTLR start "rule__Case__Group__1__Impl"
    // InternalMickeyLang.g:7534:1: rule__Case__Group__1__Impl : ( ( rule__Case__WhenExpressionAssignment_1 ) ) ;
    public final void rule__Case__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7538:1: ( ( ( rule__Case__WhenExpressionAssignment_1 ) ) )
            // InternalMickeyLang.g:7539:1: ( ( rule__Case__WhenExpressionAssignment_1 ) )
            {
            // InternalMickeyLang.g:7539:1: ( ( rule__Case__WhenExpressionAssignment_1 ) )
            // InternalMickeyLang.g:7540:2: ( rule__Case__WhenExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getWhenExpressionAssignment_1()); 
            }
            // InternalMickeyLang.g:7541:2: ( rule__Case__WhenExpressionAssignment_1 )
            // InternalMickeyLang.g:7541:3: rule__Case__WhenExpressionAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__Case__WhenExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getWhenExpressionAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__1__Impl"


    // $ANTLR start "rule__Case__Group__2"
    // InternalMickeyLang.g:7549:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ;
    public final void rule__Case__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7553:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 )
            // InternalMickeyLang.g:7554:2: rule__Case__Group__2__Impl rule__Case__Group__3
            {
            pushFollow(FOLLOW_30);
            rule__Case__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__Case__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__2"


    // $ANTLR start "rule__Case__Group__2__Impl"
    // InternalMickeyLang.g:7561:1: rule__Case__Group__2__Impl : ( 'then' ) ;
    public final void rule__Case__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7565:1: ( ( 'then' ) )
            // InternalMickeyLang.g:7566:1: ( 'then' )
            {
            // InternalMickeyLang.g:7566:1: ( 'then' )
            // InternalMickeyLang.g:7567:2: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getThenKeyword_2()); 
            }
            match(input,85,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getThenKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__2__Impl"


    // $ANTLR start "rule__Case__Group__3"
    // InternalMickeyLang.g:7576:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ;
    public final void rule__Case__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7580:1: ( rule__Case__Group__3__Impl )
            // InternalMickeyLang.g:7581:2: rule__Case__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Case__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__3"


    // $ANTLR start "rule__Case__Group__3__Impl"
    // InternalMickeyLang.g:7587:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenExpressionAssignment_3 ) ) ;
    public final void rule__Case__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7591:1: ( ( ( rule__Case__ThenExpressionAssignment_3 ) ) )
            // InternalMickeyLang.g:7592:1: ( ( rule__Case__ThenExpressionAssignment_3 ) )
            {
            // InternalMickeyLang.g:7592:1: ( ( rule__Case__ThenExpressionAssignment_3 ) )
            // InternalMickeyLang.g:7593:2: ( rule__Case__ThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getThenExpressionAssignment_3()); 
            }
            // InternalMickeyLang.g:7594:2: ( rule__Case__ThenExpressionAssignment_3 )
            // InternalMickeyLang.g:7594:3: rule__Case__ThenExpressionAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__Case__ThenExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getThenExpressionAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__Group__3__Impl"


    // $ANTLR start "rule__SelectStatement__Group__0"
    // InternalMickeyLang.g:7603:1: rule__SelectStatement__Group__0 : rule__SelectStatement__Group__0__Impl rule__SelectStatement__Group__1 ;
    public final void rule__SelectStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7607:1: ( rule__SelectStatement__Group__0__Impl rule__SelectStatement__Group__1 )
            // InternalMickeyLang.g:7608:2: rule__SelectStatement__Group__0__Impl rule__SelectStatement__Group__1
            {
            pushFollow(FOLLOW_64);
            rule__SelectStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group__0"


    // $ANTLR start "rule__SelectStatement__Group__0__Impl"
    // InternalMickeyLang.g:7615:1: rule__SelectStatement__Group__0__Impl : ( ( rule__SelectStatement__CoreAssignment_0 ) ) ;
    public final void rule__SelectStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7619:1: ( ( ( rule__SelectStatement__CoreAssignment_0 ) ) )
            // InternalMickeyLang.g:7620:1: ( ( rule__SelectStatement__CoreAssignment_0 ) )
            {
            // InternalMickeyLang.g:7620:1: ( ( rule__SelectStatement__CoreAssignment_0 ) )
            // InternalMickeyLang.g:7621:2: ( rule__SelectStatement__CoreAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getCoreAssignment_0()); 
            }
            // InternalMickeyLang.g:7622:2: ( rule__SelectStatement__CoreAssignment_0 )
            // InternalMickeyLang.g:7622:3: rule__SelectStatement__CoreAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__CoreAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getCoreAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group__0__Impl"


    // $ANTLR start "rule__SelectStatement__Group__1"
    // InternalMickeyLang.g:7630:1: rule__SelectStatement__Group__1 : rule__SelectStatement__Group__1__Impl rule__SelectStatement__Group__2 ;
    public final void rule__SelectStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7634:1: ( rule__SelectStatement__Group__1__Impl rule__SelectStatement__Group__2 )
            // InternalMickeyLang.g:7635:2: rule__SelectStatement__Group__1__Impl rule__SelectStatement__Group__2
            {
            pushFollow(FOLLOW_64);
            rule__SelectStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group__1"


    // $ANTLR start "rule__SelectStatement__Group__1__Impl"
    // InternalMickeyLang.g:7642:1: rule__SelectStatement__Group__1__Impl : ( ( rule__SelectStatement__Group_1__0 )? ) ;
    public final void rule__SelectStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7646:1: ( ( ( rule__SelectStatement__Group_1__0 )? ) )
            // InternalMickeyLang.g:7647:1: ( ( rule__SelectStatement__Group_1__0 )? )
            {
            // InternalMickeyLang.g:7647:1: ( ( rule__SelectStatement__Group_1__0 )? )
            // InternalMickeyLang.g:7648:2: ( rule__SelectStatement__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:7649:2: ( rule__SelectStatement__Group_1__0 )?
            int alt69=2;
            int LA69_0 = input.LA(1);

            if ( (LA69_0==86) ) {
                alt69=1;
            }
            switch (alt69) {
                case 1 :
                    // InternalMickeyLang.g:7649:3: rule__SelectStatement__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectStatement__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group__1__Impl"


    // $ANTLR start "rule__SelectStatement__Group__2"
    // InternalMickeyLang.g:7657:1: rule__SelectStatement__Group__2 : rule__SelectStatement__Group__2__Impl ;
    public final void rule__SelectStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7661:1: ( rule__SelectStatement__Group__2__Impl )
            // InternalMickeyLang.g:7662:2: rule__SelectStatement__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group__2"


    // $ANTLR start "rule__SelectStatement__Group__2__Impl"
    // InternalMickeyLang.g:7668:1: rule__SelectStatement__Group__2__Impl : ( ( rule__SelectStatement__Group_2__0 )? ) ;
    public final void rule__SelectStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7672:1: ( ( ( rule__SelectStatement__Group_2__0 )? ) )
            // InternalMickeyLang.g:7673:1: ( ( rule__SelectStatement__Group_2__0 )? )
            {
            // InternalMickeyLang.g:7673:1: ( ( rule__SelectStatement__Group_2__0 )? )
            // InternalMickeyLang.g:7674:2: ( rule__SelectStatement__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getGroup_2()); 
            }
            // InternalMickeyLang.g:7675:2: ( rule__SelectStatement__Group_2__0 )?
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( (LA70_0==87) ) {
                alt70=1;
            }
            switch (alt70) {
                case 1 :
                    // InternalMickeyLang.g:7675:3: rule__SelectStatement__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectStatement__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getGroup_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group__2__Impl"


    // $ANTLR start "rule__SelectStatement__Group_1__0"
    // InternalMickeyLang.g:7684:1: rule__SelectStatement__Group_1__0 : rule__SelectStatement__Group_1__0__Impl rule__SelectStatement__Group_1__1 ;
    public final void rule__SelectStatement__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7688:1: ( rule__SelectStatement__Group_1__0__Impl rule__SelectStatement__Group_1__1 )
            // InternalMickeyLang.g:7689:2: rule__SelectStatement__Group_1__0__Impl rule__SelectStatement__Group_1__1
            {
            pushFollow(FOLLOW_30);
            rule__SelectStatement__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_1__0"


    // $ANTLR start "rule__SelectStatement__Group_1__0__Impl"
    // InternalMickeyLang.g:7696:1: rule__SelectStatement__Group_1__0__Impl : ( 'order by' ) ;
    public final void rule__SelectStatement__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7700:1: ( ( 'order by' ) )
            // InternalMickeyLang.g:7701:1: ( 'order by' )
            {
            // InternalMickeyLang.g:7701:1: ( 'order by' )
            // InternalMickeyLang.g:7702:2: 'order by'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getOrderByKeyword_1_0()); 
            }
            match(input,86,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getOrderByKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_1__0__Impl"


    // $ANTLR start "rule__SelectStatement__Group_1__1"
    // InternalMickeyLang.g:7711:1: rule__SelectStatement__Group_1__1 : rule__SelectStatement__Group_1__1__Impl ;
    public final void rule__SelectStatement__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7715:1: ( rule__SelectStatement__Group_1__1__Impl )
            // InternalMickeyLang.g:7716:2: rule__SelectStatement__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_1__1"


    // $ANTLR start "rule__SelectStatement__Group_1__1__Impl"
    // InternalMickeyLang.g:7722:1: rule__SelectStatement__Group_1__1__Impl : ( ( rule__SelectStatement__OrderbyAssignment_1_1 ) ) ;
    public final void rule__SelectStatement__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7726:1: ( ( ( rule__SelectStatement__OrderbyAssignment_1_1 ) ) )
            // InternalMickeyLang.g:7727:1: ( ( rule__SelectStatement__OrderbyAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:7727:1: ( ( rule__SelectStatement__OrderbyAssignment_1_1 ) )
            // InternalMickeyLang.g:7728:2: ( rule__SelectStatement__OrderbyAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getOrderbyAssignment_1_1()); 
            }
            // InternalMickeyLang.g:7729:2: ( rule__SelectStatement__OrderbyAssignment_1_1 )
            // InternalMickeyLang.g:7729:3: rule__SelectStatement__OrderbyAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__OrderbyAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getOrderbyAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_1__1__Impl"


    // $ANTLR start "rule__SelectStatement__Group_2__0"
    // InternalMickeyLang.g:7738:1: rule__SelectStatement__Group_2__0 : rule__SelectStatement__Group_2__0__Impl rule__SelectStatement__Group_2__1 ;
    public final void rule__SelectStatement__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7742:1: ( rule__SelectStatement__Group_2__0__Impl rule__SelectStatement__Group_2__1 )
            // InternalMickeyLang.g:7743:2: rule__SelectStatement__Group_2__0__Impl rule__SelectStatement__Group_2__1
            {
            pushFollow(FOLLOW_30);
            rule__SelectStatement__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2__0"


    // $ANTLR start "rule__SelectStatement__Group_2__0__Impl"
    // InternalMickeyLang.g:7750:1: rule__SelectStatement__Group_2__0__Impl : ( 'limit' ) ;
    public final void rule__SelectStatement__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7754:1: ( ( 'limit' ) )
            // InternalMickeyLang.g:7755:1: ( 'limit' )
            {
            // InternalMickeyLang.g:7755:1: ( 'limit' )
            // InternalMickeyLang.g:7756:2: 'limit'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getLimitKeyword_2_0()); 
            }
            match(input,87,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getLimitKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2__0__Impl"


    // $ANTLR start "rule__SelectStatement__Group_2__1"
    // InternalMickeyLang.g:7765:1: rule__SelectStatement__Group_2__1 : rule__SelectStatement__Group_2__1__Impl rule__SelectStatement__Group_2__2 ;
    public final void rule__SelectStatement__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7769:1: ( rule__SelectStatement__Group_2__1__Impl rule__SelectStatement__Group_2__2 )
            // InternalMickeyLang.g:7770:2: rule__SelectStatement__Group_2__1__Impl rule__SelectStatement__Group_2__2
            {
            pushFollow(FOLLOW_65);
            rule__SelectStatement__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2__1"


    // $ANTLR start "rule__SelectStatement__Group_2__1__Impl"
    // InternalMickeyLang.g:7777:1: rule__SelectStatement__Group_2__1__Impl : ( ( rule__SelectStatement__LimitAssignment_2_1 ) ) ;
    public final void rule__SelectStatement__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7781:1: ( ( ( rule__SelectStatement__LimitAssignment_2_1 ) ) )
            // InternalMickeyLang.g:7782:1: ( ( rule__SelectStatement__LimitAssignment_2_1 ) )
            {
            // InternalMickeyLang.g:7782:1: ( ( rule__SelectStatement__LimitAssignment_2_1 ) )
            // InternalMickeyLang.g:7783:2: ( rule__SelectStatement__LimitAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getLimitAssignment_2_1()); 
            }
            // InternalMickeyLang.g:7784:2: ( rule__SelectStatement__LimitAssignment_2_1 )
            // InternalMickeyLang.g:7784:3: rule__SelectStatement__LimitAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__LimitAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getLimitAssignment_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2__1__Impl"


    // $ANTLR start "rule__SelectStatement__Group_2__2"
    // InternalMickeyLang.g:7792:1: rule__SelectStatement__Group_2__2 : rule__SelectStatement__Group_2__2__Impl ;
    public final void rule__SelectStatement__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7796:1: ( rule__SelectStatement__Group_2__2__Impl )
            // InternalMickeyLang.g:7797:2: rule__SelectStatement__Group_2__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2__2"


    // $ANTLR start "rule__SelectStatement__Group_2__2__Impl"
    // InternalMickeyLang.g:7803:1: rule__SelectStatement__Group_2__2__Impl : ( ( rule__SelectStatement__Group_2_2__0 )? ) ;
    public final void rule__SelectStatement__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7807:1: ( ( ( rule__SelectStatement__Group_2_2__0 )? ) )
            // InternalMickeyLang.g:7808:1: ( ( rule__SelectStatement__Group_2_2__0 )? )
            {
            // InternalMickeyLang.g:7808:1: ( ( rule__SelectStatement__Group_2_2__0 )? )
            // InternalMickeyLang.g:7809:2: ( rule__SelectStatement__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getGroup_2_2()); 
            }
            // InternalMickeyLang.g:7810:2: ( rule__SelectStatement__Group_2_2__0 )?
            int alt71=2;
            int LA71_0 = input.LA(1);

            if ( ((LA71_0>=39 && LA71_0<=40)) ) {
                alt71=1;
            }
            switch (alt71) {
                case 1 :
                    // InternalMickeyLang.g:7810:3: rule__SelectStatement__Group_2_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectStatement__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getGroup_2_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2__2__Impl"


    // $ANTLR start "rule__SelectStatement__Group_2_2__0"
    // InternalMickeyLang.g:7819:1: rule__SelectStatement__Group_2_2__0 : rule__SelectStatement__Group_2_2__0__Impl rule__SelectStatement__Group_2_2__1 ;
    public final void rule__SelectStatement__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7823:1: ( rule__SelectStatement__Group_2_2__0__Impl rule__SelectStatement__Group_2_2__1 )
            // InternalMickeyLang.g:7824:2: rule__SelectStatement__Group_2_2__0__Impl rule__SelectStatement__Group_2_2__1
            {
            pushFollow(FOLLOW_30);
            rule__SelectStatement__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2_2__0"


    // $ANTLR start "rule__SelectStatement__Group_2_2__0__Impl"
    // InternalMickeyLang.g:7831:1: rule__SelectStatement__Group_2_2__0__Impl : ( ( rule__SelectStatement__Alternatives_2_2_0 ) ) ;
    public final void rule__SelectStatement__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7835:1: ( ( ( rule__SelectStatement__Alternatives_2_2_0 ) ) )
            // InternalMickeyLang.g:7836:1: ( ( rule__SelectStatement__Alternatives_2_2_0 ) )
            {
            // InternalMickeyLang.g:7836:1: ( ( rule__SelectStatement__Alternatives_2_2_0 ) )
            // InternalMickeyLang.g:7837:2: ( rule__SelectStatement__Alternatives_2_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getAlternatives_2_2_0()); 
            }
            // InternalMickeyLang.g:7838:2: ( rule__SelectStatement__Alternatives_2_2_0 )
            // InternalMickeyLang.g:7838:3: rule__SelectStatement__Alternatives_2_2_0
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Alternatives_2_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getAlternatives_2_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2_2__0__Impl"


    // $ANTLR start "rule__SelectStatement__Group_2_2__1"
    // InternalMickeyLang.g:7846:1: rule__SelectStatement__Group_2_2__1 : rule__SelectStatement__Group_2_2__1__Impl ;
    public final void rule__SelectStatement__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7850:1: ( rule__SelectStatement__Group_2_2__1__Impl )
            // InternalMickeyLang.g:7851:2: rule__SelectStatement__Group_2_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2_2__1"


    // $ANTLR start "rule__SelectStatement__Group_2_2__1__Impl"
    // InternalMickeyLang.g:7857:1: rule__SelectStatement__Group_2_2__1__Impl : ( ( rule__SelectStatement__LimitOffsetAssignment_2_2_1 ) ) ;
    public final void rule__SelectStatement__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7861:1: ( ( ( rule__SelectStatement__LimitOffsetAssignment_2_2_1 ) ) )
            // InternalMickeyLang.g:7862:1: ( ( rule__SelectStatement__LimitOffsetAssignment_2_2_1 ) )
            {
            // InternalMickeyLang.g:7862:1: ( ( rule__SelectStatement__LimitOffsetAssignment_2_2_1 ) )
            // InternalMickeyLang.g:7863:2: ( rule__SelectStatement__LimitOffsetAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getLimitOffsetAssignment_2_2_1()); 
            }
            // InternalMickeyLang.g:7864:2: ( rule__SelectStatement__LimitOffsetAssignment_2_2_1 )
            // InternalMickeyLang.g:7864:3: rule__SelectStatement__LimitOffsetAssignment_2_2_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectStatement__LimitOffsetAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getLimitOffsetAssignment_2_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__Group_2_2__1__Impl"


    // $ANTLR start "rule__OrderingTermList__Group__0"
    // InternalMickeyLang.g:7873:1: rule__OrderingTermList__Group__0 : rule__OrderingTermList__Group__0__Impl rule__OrderingTermList__Group__1 ;
    public final void rule__OrderingTermList__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7877:1: ( rule__OrderingTermList__Group__0__Impl rule__OrderingTermList__Group__1 )
            // InternalMickeyLang.g:7878:2: rule__OrderingTermList__Group__0__Impl rule__OrderingTermList__Group__1
            {
            pushFollow(FOLLOW_11);
            rule__OrderingTermList__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group__0"


    // $ANTLR start "rule__OrderingTermList__Group__0__Impl"
    // InternalMickeyLang.g:7885:1: rule__OrderingTermList__Group__0__Impl : ( ( rule__OrderingTermList__OrderingTermsAssignment_0 ) ) ;
    public final void rule__OrderingTermList__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7889:1: ( ( ( rule__OrderingTermList__OrderingTermsAssignment_0 ) ) )
            // InternalMickeyLang.g:7890:1: ( ( rule__OrderingTermList__OrderingTermsAssignment_0 ) )
            {
            // InternalMickeyLang.g:7890:1: ( ( rule__OrderingTermList__OrderingTermsAssignment_0 ) )
            // InternalMickeyLang.g:7891:2: ( rule__OrderingTermList__OrderingTermsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getOrderingTermsAssignment_0()); 
            }
            // InternalMickeyLang.g:7892:2: ( rule__OrderingTermList__OrderingTermsAssignment_0 )
            // InternalMickeyLang.g:7892:3: rule__OrderingTermList__OrderingTermsAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__OrderingTermsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getOrderingTermsAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group__0__Impl"


    // $ANTLR start "rule__OrderingTermList__Group__1"
    // InternalMickeyLang.g:7900:1: rule__OrderingTermList__Group__1 : rule__OrderingTermList__Group__1__Impl ;
    public final void rule__OrderingTermList__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7904:1: ( rule__OrderingTermList__Group__1__Impl )
            // InternalMickeyLang.g:7905:2: rule__OrderingTermList__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group__1"


    // $ANTLR start "rule__OrderingTermList__Group__1__Impl"
    // InternalMickeyLang.g:7911:1: rule__OrderingTermList__Group__1__Impl : ( ( rule__OrderingTermList__Group_1__0 )* ) ;
    public final void rule__OrderingTermList__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7915:1: ( ( ( rule__OrderingTermList__Group_1__0 )* ) )
            // InternalMickeyLang.g:7916:1: ( ( rule__OrderingTermList__Group_1__0 )* )
            {
            // InternalMickeyLang.g:7916:1: ( ( rule__OrderingTermList__Group_1__0 )* )
            // InternalMickeyLang.g:7917:2: ( rule__OrderingTermList__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:7918:2: ( rule__OrderingTermList__Group_1__0 )*
            loop72:
            do {
                int alt72=2;
                int LA72_0 = input.LA(1);

                if ( (LA72_0==40) ) {
                    alt72=1;
                }


                switch (alt72) {
            	case 1 :
            	    // InternalMickeyLang.g:7918:3: rule__OrderingTermList__Group_1__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__OrderingTermList__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop72;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group__1__Impl"


    // $ANTLR start "rule__OrderingTermList__Group_1__0"
    // InternalMickeyLang.g:7927:1: rule__OrderingTermList__Group_1__0 : rule__OrderingTermList__Group_1__0__Impl rule__OrderingTermList__Group_1__1 ;
    public final void rule__OrderingTermList__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7931:1: ( rule__OrderingTermList__Group_1__0__Impl rule__OrderingTermList__Group_1__1 )
            // InternalMickeyLang.g:7932:2: rule__OrderingTermList__Group_1__0__Impl rule__OrderingTermList__Group_1__1
            {
            pushFollow(FOLLOW_30);
            rule__OrderingTermList__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group_1__0"


    // $ANTLR start "rule__OrderingTermList__Group_1__0__Impl"
    // InternalMickeyLang.g:7939:1: rule__OrderingTermList__Group_1__0__Impl : ( ',' ) ;
    public final void rule__OrderingTermList__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7943:1: ( ( ',' ) )
            // InternalMickeyLang.g:7944:1: ( ',' )
            {
            // InternalMickeyLang.g:7944:1: ( ',' )
            // InternalMickeyLang.g:7945:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getCommaKeyword_1_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getCommaKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group_1__0__Impl"


    // $ANTLR start "rule__OrderingTermList__Group_1__1"
    // InternalMickeyLang.g:7954:1: rule__OrderingTermList__Group_1__1 : rule__OrderingTermList__Group_1__1__Impl ;
    public final void rule__OrderingTermList__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7958:1: ( rule__OrderingTermList__Group_1__1__Impl )
            // InternalMickeyLang.g:7959:2: rule__OrderingTermList__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group_1__1"


    // $ANTLR start "rule__OrderingTermList__Group_1__1__Impl"
    // InternalMickeyLang.g:7965:1: rule__OrderingTermList__Group_1__1__Impl : ( ( rule__OrderingTermList__OrderingTermsAssignment_1_1 ) ) ;
    public final void rule__OrderingTermList__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7969:1: ( ( ( rule__OrderingTermList__OrderingTermsAssignment_1_1 ) ) )
            // InternalMickeyLang.g:7970:1: ( ( rule__OrderingTermList__OrderingTermsAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:7970:1: ( ( rule__OrderingTermList__OrderingTermsAssignment_1_1 ) )
            // InternalMickeyLang.g:7971:2: ( rule__OrderingTermList__OrderingTermsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getOrderingTermsAssignment_1_1()); 
            }
            // InternalMickeyLang.g:7972:2: ( rule__OrderingTermList__OrderingTermsAssignment_1_1 )
            // InternalMickeyLang.g:7972:3: rule__OrderingTermList__OrderingTermsAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTermList__OrderingTermsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getOrderingTermsAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__Group_1__1__Impl"


    // $ANTLR start "rule__SelectCore__Group__0"
    // InternalMickeyLang.g:7981:1: rule__SelectCore__Group__0 : rule__SelectCore__Group__0__Impl rule__SelectCore__Group__1 ;
    public final void rule__SelectCore__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7985:1: ( rule__SelectCore__Group__0__Impl rule__SelectCore__Group__1 )
            // InternalMickeyLang.g:7986:2: rule__SelectCore__Group__0__Impl rule__SelectCore__Group__1
            {
            pushFollow(FOLLOW_66);
            rule__SelectCore__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectCore__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group__0"


    // $ANTLR start "rule__SelectCore__Group__0__Impl"
    // InternalMickeyLang.g:7993:1: rule__SelectCore__Group__0__Impl : ( ruleSelectExpression ) ;
    public final void rule__SelectCore__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:7997:1: ( ( ruleSelectExpression ) )
            // InternalMickeyLang.g:7998:1: ( ruleSelectExpression )
            {
            // InternalMickeyLang.g:7998:1: ( ruleSelectExpression )
            // InternalMickeyLang.g:7999:2: ruleSelectExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getSelectExpressionParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getSelectExpressionParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group__0__Impl"


    // $ANTLR start "rule__SelectCore__Group__1"
    // InternalMickeyLang.g:8008:1: rule__SelectCore__Group__1 : rule__SelectCore__Group__1__Impl ;
    public final void rule__SelectCore__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8012:1: ( rule__SelectCore__Group__1__Impl )
            // InternalMickeyLang.g:8013:2: rule__SelectCore__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectCore__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group__1"


    // $ANTLR start "rule__SelectCore__Group__1__Impl"
    // InternalMickeyLang.g:8019:1: rule__SelectCore__Group__1__Impl : ( ( rule__SelectCore__Group_1__0 )* ) ;
    public final void rule__SelectCore__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8023:1: ( ( ( rule__SelectCore__Group_1__0 )* ) )
            // InternalMickeyLang.g:8024:1: ( ( rule__SelectCore__Group_1__0 )* )
            {
            // InternalMickeyLang.g:8024:1: ( ( rule__SelectCore__Group_1__0 )* )
            // InternalMickeyLang.g:8025:2: ( rule__SelectCore__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:8026:2: ( rule__SelectCore__Group_1__0 )*
            loop73:
            do {
                int alt73=2;
                int LA73_0 = input.LA(1);

                if ( ((LA73_0>=45 && LA73_0<=48)) ) {
                    alt73=1;
                }


                switch (alt73) {
            	case 1 :
            	    // InternalMickeyLang.g:8026:3: rule__SelectCore__Group_1__0
            	    {
            	    pushFollow(FOLLOW_67);
            	    rule__SelectCore__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop73;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group__1__Impl"


    // $ANTLR start "rule__SelectCore__Group_1__0"
    // InternalMickeyLang.g:8035:1: rule__SelectCore__Group_1__0 : rule__SelectCore__Group_1__0__Impl rule__SelectCore__Group_1__1 ;
    public final void rule__SelectCore__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8039:1: ( rule__SelectCore__Group_1__0__Impl rule__SelectCore__Group_1__1 )
            // InternalMickeyLang.g:8040:2: rule__SelectCore__Group_1__0__Impl rule__SelectCore__Group_1__1
            {
            pushFollow(FOLLOW_66);
            rule__SelectCore__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectCore__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group_1__0"


    // $ANTLR start "rule__SelectCore__Group_1__0__Impl"
    // InternalMickeyLang.g:8047:1: rule__SelectCore__Group_1__0__Impl : ( () ) ;
    public final void rule__SelectCore__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8051:1: ( ( () ) )
            // InternalMickeyLang.g:8052:1: ( () )
            {
            // InternalMickeyLang.g:8052:1: ( () )
            // InternalMickeyLang.g:8053:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getSelectCoreLeftAction_1_0()); 
            }
            // InternalMickeyLang.g:8054:2: ()
            // InternalMickeyLang.g:8054:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getSelectCoreLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group_1__0__Impl"


    // $ANTLR start "rule__SelectCore__Group_1__1"
    // InternalMickeyLang.g:8062:1: rule__SelectCore__Group_1__1 : rule__SelectCore__Group_1__1__Impl rule__SelectCore__Group_1__2 ;
    public final void rule__SelectCore__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8066:1: ( rule__SelectCore__Group_1__1__Impl rule__SelectCore__Group_1__2 )
            // InternalMickeyLang.g:8067:2: rule__SelectCore__Group_1__1__Impl rule__SelectCore__Group_1__2
            {
            pushFollow(FOLLOW_54);
            rule__SelectCore__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectCore__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group_1__1"


    // $ANTLR start "rule__SelectCore__Group_1__1__Impl"
    // InternalMickeyLang.g:8074:1: rule__SelectCore__Group_1__1__Impl : ( ( rule__SelectCore__OpAssignment_1_1 ) ) ;
    public final void rule__SelectCore__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8078:1: ( ( ( rule__SelectCore__OpAssignment_1_1 ) ) )
            // InternalMickeyLang.g:8079:1: ( ( rule__SelectCore__OpAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:8079:1: ( ( rule__SelectCore__OpAssignment_1_1 ) )
            // InternalMickeyLang.g:8080:2: ( rule__SelectCore__OpAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getOpAssignment_1_1()); 
            }
            // InternalMickeyLang.g:8081:2: ( rule__SelectCore__OpAssignment_1_1 )
            // InternalMickeyLang.g:8081:3: rule__SelectCore__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectCore__OpAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getOpAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group_1__1__Impl"


    // $ANTLR start "rule__SelectCore__Group_1__2"
    // InternalMickeyLang.g:8089:1: rule__SelectCore__Group_1__2 : rule__SelectCore__Group_1__2__Impl ;
    public final void rule__SelectCore__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8093:1: ( rule__SelectCore__Group_1__2__Impl )
            // InternalMickeyLang.g:8094:2: rule__SelectCore__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectCore__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group_1__2"


    // $ANTLR start "rule__SelectCore__Group_1__2__Impl"
    // InternalMickeyLang.g:8100:1: rule__SelectCore__Group_1__2__Impl : ( ( rule__SelectCore__RightAssignment_1_2 ) ) ;
    public final void rule__SelectCore__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8104:1: ( ( ( rule__SelectCore__RightAssignment_1_2 ) ) )
            // InternalMickeyLang.g:8105:1: ( ( rule__SelectCore__RightAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:8105:1: ( ( rule__SelectCore__RightAssignment_1_2 ) )
            // InternalMickeyLang.g:8106:2: ( rule__SelectCore__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getRightAssignment_1_2()); 
            }
            // InternalMickeyLang.g:8107:2: ( rule__SelectCore__RightAssignment_1_2 )
            // InternalMickeyLang.g:8107:3: rule__SelectCore__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__SelectCore__RightAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getRightAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__Group_1__2__Impl"


    // $ANTLR start "rule__SelectExpression__Group__0"
    // InternalMickeyLang.g:8116:1: rule__SelectExpression__Group__0 : rule__SelectExpression__Group__0__Impl rule__SelectExpression__Group__1 ;
    public final void rule__SelectExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8120:1: ( rule__SelectExpression__Group__0__Impl rule__SelectExpression__Group__1 )
            // InternalMickeyLang.g:8121:2: rule__SelectExpression__Group__0__Impl rule__SelectExpression__Group__1
            {
            pushFollow(FOLLOW_54);
            rule__SelectExpression__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__0"


    // $ANTLR start "rule__SelectExpression__Group__0__Impl"
    // InternalMickeyLang.g:8128:1: rule__SelectExpression__Group__0__Impl : ( () ) ;
    public final void rule__SelectExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8132:1: ( ( () ) )
            // InternalMickeyLang.g:8133:1: ( () )
            {
            // InternalMickeyLang.g:8133:1: ( () )
            // InternalMickeyLang.g:8134:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getSelectExpressionAction_0()); 
            }
            // InternalMickeyLang.g:8135:2: ()
            // InternalMickeyLang.g:8135:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getSelectExpressionAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__0__Impl"


    // $ANTLR start "rule__SelectExpression__Group__1"
    // InternalMickeyLang.g:8143:1: rule__SelectExpression__Group__1 : rule__SelectExpression__Group__1__Impl rule__SelectExpression__Group__2 ;
    public final void rule__SelectExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8147:1: ( rule__SelectExpression__Group__1__Impl rule__SelectExpression__Group__2 )
            // InternalMickeyLang.g:8148:2: rule__SelectExpression__Group__1__Impl rule__SelectExpression__Group__2
            {
            pushFollow(FOLLOW_68);
            rule__SelectExpression__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__1"


    // $ANTLR start "rule__SelectExpression__Group__1__Impl"
    // InternalMickeyLang.g:8155:1: rule__SelectExpression__Group__1__Impl : ( 'select' ) ;
    public final void rule__SelectExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8159:1: ( ( 'select' ) )
            // InternalMickeyLang.g:8160:1: ( 'select' )
            {
            // InternalMickeyLang.g:8160:1: ( 'select' )
            // InternalMickeyLang.g:8161:2: 'select'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getSelectKeyword_1()); 
            }
            match(input,88,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getSelectKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__1__Impl"


    // $ANTLR start "rule__SelectExpression__Group__2"
    // InternalMickeyLang.g:8170:1: rule__SelectExpression__Group__2 : rule__SelectExpression__Group__2__Impl rule__SelectExpression__Group__3 ;
    public final void rule__SelectExpression__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8174:1: ( rule__SelectExpression__Group__2__Impl rule__SelectExpression__Group__3 )
            // InternalMickeyLang.g:8175:2: rule__SelectExpression__Group__2__Impl rule__SelectExpression__Group__3
            {
            pushFollow(FOLLOW_68);
            rule__SelectExpression__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__2"


    // $ANTLR start "rule__SelectExpression__Group__2__Impl"
    // InternalMickeyLang.g:8182:1: rule__SelectExpression__Group__2__Impl : ( ( rule__SelectExpression__Alternatives_2 )? ) ;
    public final void rule__SelectExpression__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8186:1: ( ( ( rule__SelectExpression__Alternatives_2 )? ) )
            // InternalMickeyLang.g:8187:1: ( ( rule__SelectExpression__Alternatives_2 )? )
            {
            // InternalMickeyLang.g:8187:1: ( ( rule__SelectExpression__Alternatives_2 )? )
            // InternalMickeyLang.g:8188:2: ( rule__SelectExpression__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getAlternatives_2()); 
            }
            // InternalMickeyLang.g:8189:2: ( rule__SelectExpression__Alternatives_2 )?
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( ((LA74_0>=122 && LA74_0<=123)) ) {
                alt74=1;
            }
            switch (alt74) {
                case 1 :
                    // InternalMickeyLang.g:8189:3: rule__SelectExpression__Alternatives_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getAlternatives_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__2__Impl"


    // $ANTLR start "rule__SelectExpression__Group__3"
    // InternalMickeyLang.g:8197:1: rule__SelectExpression__Group__3 : rule__SelectExpression__Group__3__Impl rule__SelectExpression__Group__4 ;
    public final void rule__SelectExpression__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8201:1: ( rule__SelectExpression__Group__3__Impl rule__SelectExpression__Group__4 )
            // InternalMickeyLang.g:8202:2: rule__SelectExpression__Group__3__Impl rule__SelectExpression__Group__4
            {
            pushFollow(FOLLOW_69);
            rule__SelectExpression__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__3"


    // $ANTLR start "rule__SelectExpression__Group__3__Impl"
    // InternalMickeyLang.g:8209:1: rule__SelectExpression__Group__3__Impl : ( ( rule__SelectExpression__Alternatives_3 ) ) ;
    public final void rule__SelectExpression__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8213:1: ( ( ( rule__SelectExpression__Alternatives_3 ) ) )
            // InternalMickeyLang.g:8214:1: ( ( rule__SelectExpression__Alternatives_3 ) )
            {
            // InternalMickeyLang.g:8214:1: ( ( rule__SelectExpression__Alternatives_3 ) )
            // InternalMickeyLang.g:8215:2: ( rule__SelectExpression__Alternatives_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getAlternatives_3()); 
            }
            // InternalMickeyLang.g:8216:2: ( rule__SelectExpression__Alternatives_3 )
            // InternalMickeyLang.g:8216:3: rule__SelectExpression__Alternatives_3
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Alternatives_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getAlternatives_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__3__Impl"


    // $ANTLR start "rule__SelectExpression__Group__4"
    // InternalMickeyLang.g:8224:1: rule__SelectExpression__Group__4 : rule__SelectExpression__Group__4__Impl rule__SelectExpression__Group__5 ;
    public final void rule__SelectExpression__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8228:1: ( rule__SelectExpression__Group__4__Impl rule__SelectExpression__Group__5 )
            // InternalMickeyLang.g:8229:2: rule__SelectExpression__Group__4__Impl rule__SelectExpression__Group__5
            {
            pushFollow(FOLLOW_69);
            rule__SelectExpression__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__4"


    // $ANTLR start "rule__SelectExpression__Group__4__Impl"
    // InternalMickeyLang.g:8236:1: rule__SelectExpression__Group__4__Impl : ( ( rule__SelectExpression__Group_4__0 )? ) ;
    public final void rule__SelectExpression__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8240:1: ( ( ( rule__SelectExpression__Group_4__0 )? ) )
            // InternalMickeyLang.g:8241:1: ( ( rule__SelectExpression__Group_4__0 )? )
            {
            // InternalMickeyLang.g:8241:1: ( ( rule__SelectExpression__Group_4__0 )? )
            // InternalMickeyLang.g:8242:2: ( rule__SelectExpression__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroup_4()); 
            }
            // InternalMickeyLang.g:8243:2: ( rule__SelectExpression__Group_4__0 )?
            int alt75=2;
            int LA75_0 = input.LA(1);

            if ( (LA75_0==73) ) {
                alt75=1;
            }
            switch (alt75) {
                case 1 :
                    // InternalMickeyLang.g:8243:3: rule__SelectExpression__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroup_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__4__Impl"


    // $ANTLR start "rule__SelectExpression__Group__5"
    // InternalMickeyLang.g:8251:1: rule__SelectExpression__Group__5 : rule__SelectExpression__Group__5__Impl rule__SelectExpression__Group__6 ;
    public final void rule__SelectExpression__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8255:1: ( rule__SelectExpression__Group__5__Impl rule__SelectExpression__Group__6 )
            // InternalMickeyLang.g:8256:2: rule__SelectExpression__Group__5__Impl rule__SelectExpression__Group__6
            {
            pushFollow(FOLLOW_69);
            rule__SelectExpression__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__5"


    // $ANTLR start "rule__SelectExpression__Group__5__Impl"
    // InternalMickeyLang.g:8263:1: rule__SelectExpression__Group__5__Impl : ( ( rule__SelectExpression__Group_5__0 )? ) ;
    public final void rule__SelectExpression__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8267:1: ( ( ( rule__SelectExpression__Group_5__0 )? ) )
            // InternalMickeyLang.g:8268:1: ( ( rule__SelectExpression__Group_5__0 )? )
            {
            // InternalMickeyLang.g:8268:1: ( ( rule__SelectExpression__Group_5__0 )? )
            // InternalMickeyLang.g:8269:2: ( rule__SelectExpression__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroup_5()); 
            }
            // InternalMickeyLang.g:8270:2: ( rule__SelectExpression__Group_5__0 )?
            int alt76=2;
            int LA76_0 = input.LA(1);

            if ( (LA76_0==89) ) {
                alt76=1;
            }
            switch (alt76) {
                case 1 :
                    // InternalMickeyLang.g:8270:3: rule__SelectExpression__Group_5__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroup_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__5__Impl"


    // $ANTLR start "rule__SelectExpression__Group__6"
    // InternalMickeyLang.g:8278:1: rule__SelectExpression__Group__6 : rule__SelectExpression__Group__6__Impl rule__SelectExpression__Group__7 ;
    public final void rule__SelectExpression__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8282:1: ( rule__SelectExpression__Group__6__Impl rule__SelectExpression__Group__7 )
            // InternalMickeyLang.g:8283:2: rule__SelectExpression__Group__6__Impl rule__SelectExpression__Group__7
            {
            pushFollow(FOLLOW_69);
            rule__SelectExpression__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__6"


    // $ANTLR start "rule__SelectExpression__Group__6__Impl"
    // InternalMickeyLang.g:8290:1: rule__SelectExpression__Group__6__Impl : ( ( rule__SelectExpression__Group_6__0 )? ) ;
    public final void rule__SelectExpression__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8294:1: ( ( ( rule__SelectExpression__Group_6__0 )? ) )
            // InternalMickeyLang.g:8295:1: ( ( rule__SelectExpression__Group_6__0 )? )
            {
            // InternalMickeyLang.g:8295:1: ( ( rule__SelectExpression__Group_6__0 )? )
            // InternalMickeyLang.g:8296:2: ( rule__SelectExpression__Group_6__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroup_6()); 
            }
            // InternalMickeyLang.g:8297:2: ( rule__SelectExpression__Group_6__0 )?
            int alt77=2;
            int LA77_0 = input.LA(1);

            if ( (LA77_0==90) ) {
                alt77=1;
            }
            switch (alt77) {
                case 1 :
                    // InternalMickeyLang.g:8297:3: rule__SelectExpression__Group_6__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__Group_6__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroup_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__6__Impl"


    // $ANTLR start "rule__SelectExpression__Group__7"
    // InternalMickeyLang.g:8305:1: rule__SelectExpression__Group__7 : rule__SelectExpression__Group__7__Impl ;
    public final void rule__SelectExpression__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8309:1: ( rule__SelectExpression__Group__7__Impl )
            // InternalMickeyLang.g:8310:2: rule__SelectExpression__Group__7__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__7"


    // $ANTLR start "rule__SelectExpression__Group__7__Impl"
    // InternalMickeyLang.g:8316:1: rule__SelectExpression__Group__7__Impl : ( ( rule__SelectExpression__Group_7__0 )? ) ;
    public final void rule__SelectExpression__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8320:1: ( ( ( rule__SelectExpression__Group_7__0 )? ) )
            // InternalMickeyLang.g:8321:1: ( ( rule__SelectExpression__Group_7__0 )? )
            {
            // InternalMickeyLang.g:8321:1: ( ( rule__SelectExpression__Group_7__0 )? )
            // InternalMickeyLang.g:8322:2: ( rule__SelectExpression__Group_7__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroup_7()); 
            }
            // InternalMickeyLang.g:8323:2: ( rule__SelectExpression__Group_7__0 )?
            int alt78=2;
            int LA78_0 = input.LA(1);

            if ( (LA78_0==91) ) {
                alt78=1;
            }
            switch (alt78) {
                case 1 :
                    // InternalMickeyLang.g:8323:3: rule__SelectExpression__Group_7__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SelectExpression__Group_7__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroup_7()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group__7__Impl"


    // $ANTLR start "rule__SelectExpression__Group_4__0"
    // InternalMickeyLang.g:8332:1: rule__SelectExpression__Group_4__0 : rule__SelectExpression__Group_4__0__Impl rule__SelectExpression__Group_4__1 ;
    public final void rule__SelectExpression__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8336:1: ( rule__SelectExpression__Group_4__0__Impl rule__SelectExpression__Group_4__1 )
            // InternalMickeyLang.g:8337:2: rule__SelectExpression__Group_4__0__Impl rule__SelectExpression__Group_4__1
            {
            pushFollow(FOLLOW_70);
            rule__SelectExpression__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_4__0"


    // $ANTLR start "rule__SelectExpression__Group_4__0__Impl"
    // InternalMickeyLang.g:8344:1: rule__SelectExpression__Group_4__0__Impl : ( 'from' ) ;
    public final void rule__SelectExpression__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8348:1: ( ( 'from' ) )
            // InternalMickeyLang.g:8349:1: ( 'from' )
            {
            // InternalMickeyLang.g:8349:1: ( 'from' )
            // InternalMickeyLang.g:8350:2: 'from'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getFromKeyword_4_0()); 
            }
            match(input,73,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getFromKeyword_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_4__0__Impl"


    // $ANTLR start "rule__SelectExpression__Group_4__1"
    // InternalMickeyLang.g:8359:1: rule__SelectExpression__Group_4__1 : rule__SelectExpression__Group_4__1__Impl ;
    public final void rule__SelectExpression__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8363:1: ( rule__SelectExpression__Group_4__1__Impl )
            // InternalMickeyLang.g:8364:2: rule__SelectExpression__Group_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_4__1"


    // $ANTLR start "rule__SelectExpression__Group_4__1__Impl"
    // InternalMickeyLang.g:8370:1: rule__SelectExpression__Group_4__1__Impl : ( ( rule__SelectExpression__SourceAssignment_4_1 ) ) ;
    public final void rule__SelectExpression__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8374:1: ( ( ( rule__SelectExpression__SourceAssignment_4_1 ) ) )
            // InternalMickeyLang.g:8375:1: ( ( rule__SelectExpression__SourceAssignment_4_1 ) )
            {
            // InternalMickeyLang.g:8375:1: ( ( rule__SelectExpression__SourceAssignment_4_1 ) )
            // InternalMickeyLang.g:8376:2: ( rule__SelectExpression__SourceAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getSourceAssignment_4_1()); 
            }
            // InternalMickeyLang.g:8377:2: ( rule__SelectExpression__SourceAssignment_4_1 )
            // InternalMickeyLang.g:8377:3: rule__SelectExpression__SourceAssignment_4_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__SourceAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getSourceAssignment_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_4__1__Impl"


    // $ANTLR start "rule__SelectExpression__Group_5__0"
    // InternalMickeyLang.g:8386:1: rule__SelectExpression__Group_5__0 : rule__SelectExpression__Group_5__0__Impl rule__SelectExpression__Group_5__1 ;
    public final void rule__SelectExpression__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8390:1: ( rule__SelectExpression__Group_5__0__Impl rule__SelectExpression__Group_5__1 )
            // InternalMickeyLang.g:8391:2: rule__SelectExpression__Group_5__0__Impl rule__SelectExpression__Group_5__1
            {
            pushFollow(FOLLOW_30);
            rule__SelectExpression__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_5__0"


    // $ANTLR start "rule__SelectExpression__Group_5__0__Impl"
    // InternalMickeyLang.g:8398:1: rule__SelectExpression__Group_5__0__Impl : ( 'where' ) ;
    public final void rule__SelectExpression__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8402:1: ( ( 'where' ) )
            // InternalMickeyLang.g:8403:1: ( 'where' )
            {
            // InternalMickeyLang.g:8403:1: ( 'where' )
            // InternalMickeyLang.g:8404:2: 'where'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getWhereKeyword_5_0()); 
            }
            match(input,89,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getWhereKeyword_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_5__0__Impl"


    // $ANTLR start "rule__SelectExpression__Group_5__1"
    // InternalMickeyLang.g:8413:1: rule__SelectExpression__Group_5__1 : rule__SelectExpression__Group_5__1__Impl ;
    public final void rule__SelectExpression__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8417:1: ( rule__SelectExpression__Group_5__1__Impl )
            // InternalMickeyLang.g:8418:2: rule__SelectExpression__Group_5__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_5__1"


    // $ANTLR start "rule__SelectExpression__Group_5__1__Impl"
    // InternalMickeyLang.g:8424:1: rule__SelectExpression__Group_5__1__Impl : ( ( rule__SelectExpression__WhereAssignment_5_1 ) ) ;
    public final void rule__SelectExpression__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8428:1: ( ( ( rule__SelectExpression__WhereAssignment_5_1 ) ) )
            // InternalMickeyLang.g:8429:1: ( ( rule__SelectExpression__WhereAssignment_5_1 ) )
            {
            // InternalMickeyLang.g:8429:1: ( ( rule__SelectExpression__WhereAssignment_5_1 ) )
            // InternalMickeyLang.g:8430:2: ( rule__SelectExpression__WhereAssignment_5_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getWhereAssignment_5_1()); 
            }
            // InternalMickeyLang.g:8431:2: ( rule__SelectExpression__WhereAssignment_5_1 )
            // InternalMickeyLang.g:8431:3: rule__SelectExpression__WhereAssignment_5_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__WhereAssignment_5_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getWhereAssignment_5_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_5__1__Impl"


    // $ANTLR start "rule__SelectExpression__Group_6__0"
    // InternalMickeyLang.g:8440:1: rule__SelectExpression__Group_6__0 : rule__SelectExpression__Group_6__0__Impl rule__SelectExpression__Group_6__1 ;
    public final void rule__SelectExpression__Group_6__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8444:1: ( rule__SelectExpression__Group_6__0__Impl rule__SelectExpression__Group_6__1 )
            // InternalMickeyLang.g:8445:2: rule__SelectExpression__Group_6__0__Impl rule__SelectExpression__Group_6__1
            {
            pushFollow(FOLLOW_30);
            rule__SelectExpression__Group_6__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_6__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_6__0"


    // $ANTLR start "rule__SelectExpression__Group_6__0__Impl"
    // InternalMickeyLang.g:8452:1: rule__SelectExpression__Group_6__0__Impl : ( 'group by' ) ;
    public final void rule__SelectExpression__Group_6__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8456:1: ( ( 'group by' ) )
            // InternalMickeyLang.g:8457:1: ( 'group by' )
            {
            // InternalMickeyLang.g:8457:1: ( 'group by' )
            // InternalMickeyLang.g:8458:2: 'group by'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroupByKeyword_6_0()); 
            }
            match(input,90,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroupByKeyword_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_6__0__Impl"


    // $ANTLR start "rule__SelectExpression__Group_6__1"
    // InternalMickeyLang.g:8467:1: rule__SelectExpression__Group_6__1 : rule__SelectExpression__Group_6__1__Impl ;
    public final void rule__SelectExpression__Group_6__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8471:1: ( rule__SelectExpression__Group_6__1__Impl )
            // InternalMickeyLang.g:8472:2: rule__SelectExpression__Group_6__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_6__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_6__1"


    // $ANTLR start "rule__SelectExpression__Group_6__1__Impl"
    // InternalMickeyLang.g:8478:1: rule__SelectExpression__Group_6__1__Impl : ( ( rule__SelectExpression__GroupByAssignment_6_1 ) ) ;
    public final void rule__SelectExpression__Group_6__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8482:1: ( ( ( rule__SelectExpression__GroupByAssignment_6_1 ) ) )
            // InternalMickeyLang.g:8483:1: ( ( rule__SelectExpression__GroupByAssignment_6_1 ) )
            {
            // InternalMickeyLang.g:8483:1: ( ( rule__SelectExpression__GroupByAssignment_6_1 ) )
            // InternalMickeyLang.g:8484:2: ( rule__SelectExpression__GroupByAssignment_6_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroupByAssignment_6_1()); 
            }
            // InternalMickeyLang.g:8485:2: ( rule__SelectExpression__GroupByAssignment_6_1 )
            // InternalMickeyLang.g:8485:3: rule__SelectExpression__GroupByAssignment_6_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__GroupByAssignment_6_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroupByAssignment_6_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_6__1__Impl"


    // $ANTLR start "rule__SelectExpression__Group_7__0"
    // InternalMickeyLang.g:8494:1: rule__SelectExpression__Group_7__0 : rule__SelectExpression__Group_7__0__Impl rule__SelectExpression__Group_7__1 ;
    public final void rule__SelectExpression__Group_7__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8498:1: ( rule__SelectExpression__Group_7__0__Impl rule__SelectExpression__Group_7__1 )
            // InternalMickeyLang.g:8499:2: rule__SelectExpression__Group_7__0__Impl rule__SelectExpression__Group_7__1
            {
            pushFollow(FOLLOW_30);
            rule__SelectExpression__Group_7__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_7__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_7__0"


    // $ANTLR start "rule__SelectExpression__Group_7__0__Impl"
    // InternalMickeyLang.g:8506:1: rule__SelectExpression__Group_7__0__Impl : ( 'having' ) ;
    public final void rule__SelectExpression__Group_7__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8510:1: ( ( 'having' ) )
            // InternalMickeyLang.g:8511:1: ( 'having' )
            {
            // InternalMickeyLang.g:8511:1: ( 'having' )
            // InternalMickeyLang.g:8512:2: 'having'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getHavingKeyword_7_0()); 
            }
            match(input,91,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getHavingKeyword_7_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_7__0__Impl"


    // $ANTLR start "rule__SelectExpression__Group_7__1"
    // InternalMickeyLang.g:8521:1: rule__SelectExpression__Group_7__1 : rule__SelectExpression__Group_7__1__Impl ;
    public final void rule__SelectExpression__Group_7__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8525:1: ( rule__SelectExpression__Group_7__1__Impl )
            // InternalMickeyLang.g:8526:2: rule__SelectExpression__Group_7__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__Group_7__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_7__1"


    // $ANTLR start "rule__SelectExpression__Group_7__1__Impl"
    // InternalMickeyLang.g:8532:1: rule__SelectExpression__Group_7__1__Impl : ( ( rule__SelectExpression__HavingAssignment_7_1 ) ) ;
    public final void rule__SelectExpression__Group_7__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8536:1: ( ( ( rule__SelectExpression__HavingAssignment_7_1 ) ) )
            // InternalMickeyLang.g:8537:1: ( ( rule__SelectExpression__HavingAssignment_7_1 ) )
            {
            // InternalMickeyLang.g:8537:1: ( ( rule__SelectExpression__HavingAssignment_7_1 ) )
            // InternalMickeyLang.g:8538:2: ( rule__SelectExpression__HavingAssignment_7_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getHavingAssignment_7_1()); 
            }
            // InternalMickeyLang.g:8539:2: ( rule__SelectExpression__HavingAssignment_7_1 )
            // InternalMickeyLang.g:8539:3: rule__SelectExpression__HavingAssignment_7_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectExpression__HavingAssignment_7_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getHavingAssignment_7_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__Group_7__1__Impl"


    // $ANTLR start "rule__SelectList__Group__0"
    // InternalMickeyLang.g:8548:1: rule__SelectList__Group__0 : rule__SelectList__Group__0__Impl rule__SelectList__Group__1 ;
    public final void rule__SelectList__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8552:1: ( rule__SelectList__Group__0__Impl rule__SelectList__Group__1 )
            // InternalMickeyLang.g:8553:2: rule__SelectList__Group__0__Impl rule__SelectList__Group__1
            {
            pushFollow(FOLLOW_11);
            rule__SelectList__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectList__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group__0"


    // $ANTLR start "rule__SelectList__Group__0__Impl"
    // InternalMickeyLang.g:8560:1: rule__SelectList__Group__0__Impl : ( ( rule__SelectList__ResultColumnsAssignment_0 ) ) ;
    public final void rule__SelectList__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8564:1: ( ( ( rule__SelectList__ResultColumnsAssignment_0 ) ) )
            // InternalMickeyLang.g:8565:1: ( ( rule__SelectList__ResultColumnsAssignment_0 ) )
            {
            // InternalMickeyLang.g:8565:1: ( ( rule__SelectList__ResultColumnsAssignment_0 ) )
            // InternalMickeyLang.g:8566:2: ( rule__SelectList__ResultColumnsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getResultColumnsAssignment_0()); 
            }
            // InternalMickeyLang.g:8567:2: ( rule__SelectList__ResultColumnsAssignment_0 )
            // InternalMickeyLang.g:8567:3: rule__SelectList__ResultColumnsAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__SelectList__ResultColumnsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getResultColumnsAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group__0__Impl"


    // $ANTLR start "rule__SelectList__Group__1"
    // InternalMickeyLang.g:8575:1: rule__SelectList__Group__1 : rule__SelectList__Group__1__Impl ;
    public final void rule__SelectList__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8579:1: ( rule__SelectList__Group__1__Impl )
            // InternalMickeyLang.g:8580:2: rule__SelectList__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectList__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group__1"


    // $ANTLR start "rule__SelectList__Group__1__Impl"
    // InternalMickeyLang.g:8586:1: rule__SelectList__Group__1__Impl : ( ( rule__SelectList__Group_1__0 )* ) ;
    public final void rule__SelectList__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8590:1: ( ( ( rule__SelectList__Group_1__0 )* ) )
            // InternalMickeyLang.g:8591:1: ( ( rule__SelectList__Group_1__0 )* )
            {
            // InternalMickeyLang.g:8591:1: ( ( rule__SelectList__Group_1__0 )* )
            // InternalMickeyLang.g:8592:2: ( rule__SelectList__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:8593:2: ( rule__SelectList__Group_1__0 )*
            loop79:
            do {
                int alt79=2;
                int LA79_0 = input.LA(1);

                if ( (LA79_0==40) ) {
                    alt79=1;
                }


                switch (alt79) {
            	case 1 :
            	    // InternalMickeyLang.g:8593:3: rule__SelectList__Group_1__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__SelectList__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop79;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group__1__Impl"


    // $ANTLR start "rule__SelectList__Group_1__0"
    // InternalMickeyLang.g:8602:1: rule__SelectList__Group_1__0 : rule__SelectList__Group_1__0__Impl rule__SelectList__Group_1__1 ;
    public final void rule__SelectList__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8606:1: ( rule__SelectList__Group_1__0__Impl rule__SelectList__Group_1__1 )
            // InternalMickeyLang.g:8607:2: rule__SelectList__Group_1__0__Impl rule__SelectList__Group_1__1
            {
            pushFollow(FOLLOW_68);
            rule__SelectList__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SelectList__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group_1__0"


    // $ANTLR start "rule__SelectList__Group_1__0__Impl"
    // InternalMickeyLang.g:8614:1: rule__SelectList__Group_1__0__Impl : ( ',' ) ;
    public final void rule__SelectList__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8618:1: ( ( ',' ) )
            // InternalMickeyLang.g:8619:1: ( ',' )
            {
            // InternalMickeyLang.g:8619:1: ( ',' )
            // InternalMickeyLang.g:8620:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getCommaKeyword_1_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getCommaKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group_1__0__Impl"


    // $ANTLR start "rule__SelectList__Group_1__1"
    // InternalMickeyLang.g:8629:1: rule__SelectList__Group_1__1 : rule__SelectList__Group_1__1__Impl ;
    public final void rule__SelectList__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8633:1: ( rule__SelectList__Group_1__1__Impl )
            // InternalMickeyLang.g:8634:2: rule__SelectList__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SelectList__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group_1__1"


    // $ANTLR start "rule__SelectList__Group_1__1__Impl"
    // InternalMickeyLang.g:8640:1: rule__SelectList__Group_1__1__Impl : ( ( rule__SelectList__ResultColumnsAssignment_1_1 ) ) ;
    public final void rule__SelectList__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8644:1: ( ( ( rule__SelectList__ResultColumnsAssignment_1_1 ) ) )
            // InternalMickeyLang.g:8645:1: ( ( rule__SelectList__ResultColumnsAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:8645:1: ( ( rule__SelectList__ResultColumnsAssignment_1_1 ) )
            // InternalMickeyLang.g:8646:2: ( rule__SelectList__ResultColumnsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getResultColumnsAssignment_1_1()); 
            }
            // InternalMickeyLang.g:8647:2: ( rule__SelectList__ResultColumnsAssignment_1_1 )
            // InternalMickeyLang.g:8647:3: rule__SelectList__ResultColumnsAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__SelectList__ResultColumnsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getResultColumnsAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__Group_1__1__Impl"


    // $ANTLR start "rule__GroupByExpressions__Group__0"
    // InternalMickeyLang.g:8656:1: rule__GroupByExpressions__Group__0 : rule__GroupByExpressions__Group__0__Impl rule__GroupByExpressions__Group__1 ;
    public final void rule__GroupByExpressions__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8660:1: ( rule__GroupByExpressions__Group__0__Impl rule__GroupByExpressions__Group__1 )
            // InternalMickeyLang.g:8661:2: rule__GroupByExpressions__Group__0__Impl rule__GroupByExpressions__Group__1
            {
            pushFollow(FOLLOW_11);
            rule__GroupByExpressions__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group__0"


    // $ANTLR start "rule__GroupByExpressions__Group__0__Impl"
    // InternalMickeyLang.g:8668:1: rule__GroupByExpressions__Group__0__Impl : ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_0 ) ) ;
    public final void rule__GroupByExpressions__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8672:1: ( ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_0 ) ) )
            // InternalMickeyLang.g:8673:1: ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_0 ) )
            {
            // InternalMickeyLang.g:8673:1: ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_0 ) )
            // InternalMickeyLang.g:8674:2: ( rule__GroupByExpressions__GroupByExpressionsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsAssignment_0()); 
            }
            // InternalMickeyLang.g:8675:2: ( rule__GroupByExpressions__GroupByExpressionsAssignment_0 )
            // InternalMickeyLang.g:8675:3: rule__GroupByExpressions__GroupByExpressionsAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__GroupByExpressionsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group__0__Impl"


    // $ANTLR start "rule__GroupByExpressions__Group__1"
    // InternalMickeyLang.g:8683:1: rule__GroupByExpressions__Group__1 : rule__GroupByExpressions__Group__1__Impl ;
    public final void rule__GroupByExpressions__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8687:1: ( rule__GroupByExpressions__Group__1__Impl )
            // InternalMickeyLang.g:8688:2: rule__GroupByExpressions__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group__1"


    // $ANTLR start "rule__GroupByExpressions__Group__1__Impl"
    // InternalMickeyLang.g:8694:1: rule__GroupByExpressions__Group__1__Impl : ( ( rule__GroupByExpressions__Group_1__0 )* ) ;
    public final void rule__GroupByExpressions__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8698:1: ( ( ( rule__GroupByExpressions__Group_1__0 )* ) )
            // InternalMickeyLang.g:8699:1: ( ( rule__GroupByExpressions__Group_1__0 )* )
            {
            // InternalMickeyLang.g:8699:1: ( ( rule__GroupByExpressions__Group_1__0 )* )
            // InternalMickeyLang.g:8700:2: ( rule__GroupByExpressions__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:8701:2: ( rule__GroupByExpressions__Group_1__0 )*
            loop80:
            do {
                int alt80=2;
                int LA80_0 = input.LA(1);

                if ( (LA80_0==40) ) {
                    alt80=1;
                }


                switch (alt80) {
            	case 1 :
            	    // InternalMickeyLang.g:8701:3: rule__GroupByExpressions__Group_1__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__GroupByExpressions__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop80;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group__1__Impl"


    // $ANTLR start "rule__GroupByExpressions__Group_1__0"
    // InternalMickeyLang.g:8710:1: rule__GroupByExpressions__Group_1__0 : rule__GroupByExpressions__Group_1__0__Impl rule__GroupByExpressions__Group_1__1 ;
    public final void rule__GroupByExpressions__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8714:1: ( rule__GroupByExpressions__Group_1__0__Impl rule__GroupByExpressions__Group_1__1 )
            // InternalMickeyLang.g:8715:2: rule__GroupByExpressions__Group_1__0__Impl rule__GroupByExpressions__Group_1__1
            {
            pushFollow(FOLLOW_30);
            rule__GroupByExpressions__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group_1__0"


    // $ANTLR start "rule__GroupByExpressions__Group_1__0__Impl"
    // InternalMickeyLang.g:8722:1: rule__GroupByExpressions__Group_1__0__Impl : ( ',' ) ;
    public final void rule__GroupByExpressions__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8726:1: ( ( ',' ) )
            // InternalMickeyLang.g:8727:1: ( ',' )
            {
            // InternalMickeyLang.g:8727:1: ( ',' )
            // InternalMickeyLang.g:8728:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getCommaKeyword_1_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getCommaKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group_1__0__Impl"


    // $ANTLR start "rule__GroupByExpressions__Group_1__1"
    // InternalMickeyLang.g:8737:1: rule__GroupByExpressions__Group_1__1 : rule__GroupByExpressions__Group_1__1__Impl ;
    public final void rule__GroupByExpressions__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8741:1: ( rule__GroupByExpressions__Group_1__1__Impl )
            // InternalMickeyLang.g:8742:2: rule__GroupByExpressions__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group_1__1"


    // $ANTLR start "rule__GroupByExpressions__Group_1__1__Impl"
    // InternalMickeyLang.g:8748:1: rule__GroupByExpressions__Group_1__1__Impl : ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 ) ) ;
    public final void rule__GroupByExpressions__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8752:1: ( ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 ) ) )
            // InternalMickeyLang.g:8753:1: ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:8753:1: ( ( rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 ) )
            // InternalMickeyLang.g:8754:2: ( rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsAssignment_1_1()); 
            }
            // InternalMickeyLang.g:8755:2: ( rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 )
            // InternalMickeyLang.g:8755:3: rule__GroupByExpressions__GroupByExpressionsAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__GroupByExpressions__GroupByExpressionsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__Group_1__1__Impl"


    // $ANTLR start "rule__OrderingTerm__Group__0"
    // InternalMickeyLang.g:8764:1: rule__OrderingTerm__Group__0 : rule__OrderingTerm__Group__0__Impl rule__OrderingTerm__Group__1 ;
    public final void rule__OrderingTerm__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8768:1: ( rule__OrderingTerm__Group__0__Impl rule__OrderingTerm__Group__1 )
            // InternalMickeyLang.g:8769:2: rule__OrderingTerm__Group__0__Impl rule__OrderingTerm__Group__1
            {
            pushFollow(FOLLOW_71);
            rule__OrderingTerm__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__OrderingTerm__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__Group__0"


    // $ANTLR start "rule__OrderingTerm__Group__0__Impl"
    // InternalMickeyLang.g:8776:1: rule__OrderingTerm__Group__0__Impl : ( ( rule__OrderingTerm__ExpressionAssignment_0 ) ) ;
    public final void rule__OrderingTerm__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8780:1: ( ( ( rule__OrderingTerm__ExpressionAssignment_0 ) ) )
            // InternalMickeyLang.g:8781:1: ( ( rule__OrderingTerm__ExpressionAssignment_0 ) )
            {
            // InternalMickeyLang.g:8781:1: ( ( rule__OrderingTerm__ExpressionAssignment_0 ) )
            // InternalMickeyLang.g:8782:2: ( rule__OrderingTerm__ExpressionAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getExpressionAssignment_0()); 
            }
            // InternalMickeyLang.g:8783:2: ( rule__OrderingTerm__ExpressionAssignment_0 )
            // InternalMickeyLang.g:8783:3: rule__OrderingTerm__ExpressionAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTerm__ExpressionAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getExpressionAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__Group__0__Impl"


    // $ANTLR start "rule__OrderingTerm__Group__1"
    // InternalMickeyLang.g:8791:1: rule__OrderingTerm__Group__1 : rule__OrderingTerm__Group__1__Impl ;
    public final void rule__OrderingTerm__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8795:1: ( rule__OrderingTerm__Group__1__Impl )
            // InternalMickeyLang.g:8796:2: rule__OrderingTerm__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__OrderingTerm__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__Group__1"


    // $ANTLR start "rule__OrderingTerm__Group__1__Impl"
    // InternalMickeyLang.g:8802:1: rule__OrderingTerm__Group__1__Impl : ( ( rule__OrderingTerm__Alternatives_1 )? ) ;
    public final void rule__OrderingTerm__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8806:1: ( ( ( rule__OrderingTerm__Alternatives_1 )? ) )
            // InternalMickeyLang.g:8807:1: ( ( rule__OrderingTerm__Alternatives_1 )? )
            {
            // InternalMickeyLang.g:8807:1: ( ( rule__OrderingTerm__Alternatives_1 )? )
            // InternalMickeyLang.g:8808:2: ( rule__OrderingTerm__Alternatives_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getAlternatives_1()); 
            }
            // InternalMickeyLang.g:8809:2: ( rule__OrderingTerm__Alternatives_1 )?
            int alt81=2;
            int LA81_0 = input.LA(1);

            if ( ((LA81_0>=124 && LA81_0<=125)) ) {
                alt81=1;
            }
            switch (alt81) {
                case 1 :
                    // InternalMickeyLang.g:8809:3: rule__OrderingTerm__Alternatives_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__OrderingTerm__Alternatives_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getAlternatives_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__Group__1__Impl"


    // $ANTLR start "rule__JoinSource__Group__0"
    // InternalMickeyLang.g:8818:1: rule__JoinSource__Group__0 : rule__JoinSource__Group__0__Impl rule__JoinSource__Group__1 ;
    public final void rule__JoinSource__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8822:1: ( rule__JoinSource__Group__0__Impl rule__JoinSource__Group__1 )
            // InternalMickeyLang.g:8823:2: rule__JoinSource__Group__0__Impl rule__JoinSource__Group__1
            {
            pushFollow(FOLLOW_72);
            rule__JoinSource__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinSource__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinSource__Group__0"


    // $ANTLR start "rule__JoinSource__Group__0__Impl"
    // InternalMickeyLang.g:8830:1: rule__JoinSource__Group__0__Impl : ( ( rule__JoinSource__SourceAssignment_0 ) ) ;
    public final void rule__JoinSource__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8834:1: ( ( ( rule__JoinSource__SourceAssignment_0 ) ) )
            // InternalMickeyLang.g:8835:1: ( ( rule__JoinSource__SourceAssignment_0 ) )
            {
            // InternalMickeyLang.g:8835:1: ( ( rule__JoinSource__SourceAssignment_0 ) )
            // InternalMickeyLang.g:8836:2: ( rule__JoinSource__SourceAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinSourceAccess().getSourceAssignment_0()); 
            }
            // InternalMickeyLang.g:8837:2: ( rule__JoinSource__SourceAssignment_0 )
            // InternalMickeyLang.g:8837:3: rule__JoinSource__SourceAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__JoinSource__SourceAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinSourceAccess().getSourceAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinSource__Group__0__Impl"


    // $ANTLR start "rule__JoinSource__Group__1"
    // InternalMickeyLang.g:8845:1: rule__JoinSource__Group__1 : rule__JoinSource__Group__1__Impl ;
    public final void rule__JoinSource__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8849:1: ( rule__JoinSource__Group__1__Impl )
            // InternalMickeyLang.g:8850:2: rule__JoinSource__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__JoinSource__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinSource__Group__1"


    // $ANTLR start "rule__JoinSource__Group__1__Impl"
    // InternalMickeyLang.g:8856:1: rule__JoinSource__Group__1__Impl : ( ( rule__JoinSource__JoinStatementsAssignment_1 )* ) ;
    public final void rule__JoinSource__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8860:1: ( ( ( rule__JoinSource__JoinStatementsAssignment_1 )* ) )
            // InternalMickeyLang.g:8861:1: ( ( rule__JoinSource__JoinStatementsAssignment_1 )* )
            {
            // InternalMickeyLang.g:8861:1: ( ( rule__JoinSource__JoinStatementsAssignment_1 )* )
            // InternalMickeyLang.g:8862:2: ( rule__JoinSource__JoinStatementsAssignment_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinSourceAccess().getJoinStatementsAssignment_1()); 
            }
            // InternalMickeyLang.g:8863:2: ( rule__JoinSource__JoinStatementsAssignment_1 )*
            loop82:
            do {
                int alt82=2;
                int LA82_0 = input.LA(1);

                if ( (LA82_0==92||(LA82_0>=126 && LA82_0<=127)||(LA82_0>=129 && LA82_0<=130)) ) {
                    alt82=1;
                }


                switch (alt82) {
            	case 1 :
            	    // InternalMickeyLang.g:8863:3: rule__JoinSource__JoinStatementsAssignment_1
            	    {
            	    pushFollow(FOLLOW_73);
            	    rule__JoinSource__JoinStatementsAssignment_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop82;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinSourceAccess().getJoinStatementsAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinSource__Group__1__Impl"


    // $ANTLR start "rule__SingleSourceTable__Group__0"
    // InternalMickeyLang.g:8872:1: rule__SingleSourceTable__Group__0 : rule__SingleSourceTable__Group__0__Impl rule__SingleSourceTable__Group__1 ;
    public final void rule__SingleSourceTable__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8876:1: ( rule__SingleSourceTable__Group__0__Impl rule__SingleSourceTable__Group__1 )
            // InternalMickeyLang.g:8877:2: rule__SingleSourceTable__Group__0__Impl rule__SingleSourceTable__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__SingleSourceTable__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group__0"


    // $ANTLR start "rule__SingleSourceTable__Group__0__Impl"
    // InternalMickeyLang.g:8884:1: rule__SingleSourceTable__Group__0__Impl : ( () ) ;
    public final void rule__SingleSourceTable__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8888:1: ( ( () ) )
            // InternalMickeyLang.g:8889:1: ( () )
            {
            // InternalMickeyLang.g:8889:1: ( () )
            // InternalMickeyLang.g:8890:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getSingleSourceTableAction_0()); 
            }
            // InternalMickeyLang.g:8891:2: ()
            // InternalMickeyLang.g:8891:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getSingleSourceTableAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group__0__Impl"


    // $ANTLR start "rule__SingleSourceTable__Group__1"
    // InternalMickeyLang.g:8899:1: rule__SingleSourceTable__Group__1 : rule__SingleSourceTable__Group__1__Impl rule__SingleSourceTable__Group__2 ;
    public final void rule__SingleSourceTable__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8903:1: ( rule__SingleSourceTable__Group__1__Impl rule__SingleSourceTable__Group__2 )
            // InternalMickeyLang.g:8904:2: rule__SingleSourceTable__Group__1__Impl rule__SingleSourceTable__Group__2
            {
            pushFollow(FOLLOW_61);
            rule__SingleSourceTable__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group__1"


    // $ANTLR start "rule__SingleSourceTable__Group__1__Impl"
    // InternalMickeyLang.g:8911:1: rule__SingleSourceTable__Group__1__Impl : ( ( rule__SingleSourceTable__TableReferenceAssignment_1 ) ) ;
    public final void rule__SingleSourceTable__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8915:1: ( ( ( rule__SingleSourceTable__TableReferenceAssignment_1 ) ) )
            // InternalMickeyLang.g:8916:1: ( ( rule__SingleSourceTable__TableReferenceAssignment_1 ) )
            {
            // InternalMickeyLang.g:8916:1: ( ( rule__SingleSourceTable__TableReferenceAssignment_1 ) )
            // InternalMickeyLang.g:8917:2: ( rule__SingleSourceTable__TableReferenceAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getTableReferenceAssignment_1()); 
            }
            // InternalMickeyLang.g:8918:2: ( rule__SingleSourceTable__TableReferenceAssignment_1 )
            // InternalMickeyLang.g:8918:3: rule__SingleSourceTable__TableReferenceAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__TableReferenceAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getTableReferenceAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group__1__Impl"


    // $ANTLR start "rule__SingleSourceTable__Group__2"
    // InternalMickeyLang.g:8926:1: rule__SingleSourceTable__Group__2 : rule__SingleSourceTable__Group__2__Impl ;
    public final void rule__SingleSourceTable__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8930:1: ( rule__SingleSourceTable__Group__2__Impl )
            // InternalMickeyLang.g:8931:2: rule__SingleSourceTable__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group__2"


    // $ANTLR start "rule__SingleSourceTable__Group__2__Impl"
    // InternalMickeyLang.g:8937:1: rule__SingleSourceTable__Group__2__Impl : ( ( rule__SingleSourceTable__Group_2__0 )? ) ;
    public final void rule__SingleSourceTable__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8941:1: ( ( ( rule__SingleSourceTable__Group_2__0 )? ) )
            // InternalMickeyLang.g:8942:1: ( ( rule__SingleSourceTable__Group_2__0 )? )
            {
            // InternalMickeyLang.g:8942:1: ( ( rule__SingleSourceTable__Group_2__0 )? )
            // InternalMickeyLang.g:8943:2: ( rule__SingleSourceTable__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getGroup_2()); 
            }
            // InternalMickeyLang.g:8944:2: ( rule__SingleSourceTable__Group_2__0 )?
            int alt83=2;
            int LA83_0 = input.LA(1);

            if ( (LA83_0==82) ) {
                alt83=1;
            }
            switch (alt83) {
                case 1 :
                    // InternalMickeyLang.g:8944:3: rule__SingleSourceTable__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SingleSourceTable__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getGroup_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group__2__Impl"


    // $ANTLR start "rule__SingleSourceTable__Group_2__0"
    // InternalMickeyLang.g:8953:1: rule__SingleSourceTable__Group_2__0 : rule__SingleSourceTable__Group_2__0__Impl rule__SingleSourceTable__Group_2__1 ;
    public final void rule__SingleSourceTable__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8957:1: ( rule__SingleSourceTable__Group_2__0__Impl rule__SingleSourceTable__Group_2__1 )
            // InternalMickeyLang.g:8958:2: rule__SingleSourceTable__Group_2__0__Impl rule__SingleSourceTable__Group_2__1
            {
            pushFollow(FOLLOW_3);
            rule__SingleSourceTable__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group_2__0"


    // $ANTLR start "rule__SingleSourceTable__Group_2__0__Impl"
    // InternalMickeyLang.g:8965:1: rule__SingleSourceTable__Group_2__0__Impl : ( 'as' ) ;
    public final void rule__SingleSourceTable__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8969:1: ( ( 'as' ) )
            // InternalMickeyLang.g:8970:1: ( 'as' )
            {
            // InternalMickeyLang.g:8970:1: ( 'as' )
            // InternalMickeyLang.g:8971:2: 'as'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getAsKeyword_2_0()); 
            }
            match(input,82,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getAsKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group_2__0__Impl"


    // $ANTLR start "rule__SingleSourceTable__Group_2__1"
    // InternalMickeyLang.g:8980:1: rule__SingleSourceTable__Group_2__1 : rule__SingleSourceTable__Group_2__1__Impl ;
    public final void rule__SingleSourceTable__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8984:1: ( rule__SingleSourceTable__Group_2__1__Impl )
            // InternalMickeyLang.g:8985:2: rule__SingleSourceTable__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group_2__1"


    // $ANTLR start "rule__SingleSourceTable__Group_2__1__Impl"
    // InternalMickeyLang.g:8991:1: rule__SingleSourceTable__Group_2__1__Impl : ( ( rule__SingleSourceTable__NameAssignment_2_1 ) ) ;
    public final void rule__SingleSourceTable__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:8995:1: ( ( ( rule__SingleSourceTable__NameAssignment_2_1 ) ) )
            // InternalMickeyLang.g:8996:1: ( ( rule__SingleSourceTable__NameAssignment_2_1 ) )
            {
            // InternalMickeyLang.g:8996:1: ( ( rule__SingleSourceTable__NameAssignment_2_1 ) )
            // InternalMickeyLang.g:8997:2: ( rule__SingleSourceTable__NameAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getNameAssignment_2_1()); 
            }
            // InternalMickeyLang.g:8998:2: ( rule__SingleSourceTable__NameAssignment_2_1 )
            // InternalMickeyLang.g:8998:3: rule__SingleSourceTable__NameAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceTable__NameAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getNameAssignment_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__Group_2__1__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__0"
    // InternalMickeyLang.g:9007:1: rule__SingleSourceSelectStatement__Group__0 : rule__SingleSourceSelectStatement__Group__0__Impl rule__SingleSourceSelectStatement__Group__1 ;
    public final void rule__SingleSourceSelectStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9011:1: ( rule__SingleSourceSelectStatement__Group__0__Impl rule__SingleSourceSelectStatement__Group__1 )
            // InternalMickeyLang.g:9012:2: rule__SingleSourceSelectStatement__Group__0__Impl rule__SingleSourceSelectStatement__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__SingleSourceSelectStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__0"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__0__Impl"
    // InternalMickeyLang.g:9019:1: rule__SingleSourceSelectStatement__Group__0__Impl : ( () ) ;
    public final void rule__SingleSourceSelectStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9023:1: ( ( () ) )
            // InternalMickeyLang.g:9024:1: ( () )
            {
            // InternalMickeyLang.g:9024:1: ( () )
            // InternalMickeyLang.g:9025:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getSingleSourceSelectStatementAction_0()); 
            }
            // InternalMickeyLang.g:9026:2: ()
            // InternalMickeyLang.g:9026:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getSingleSourceSelectStatementAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__0__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__1"
    // InternalMickeyLang.g:9034:1: rule__SingleSourceSelectStatement__Group__1 : rule__SingleSourceSelectStatement__Group__1__Impl rule__SingleSourceSelectStatement__Group__2 ;
    public final void rule__SingleSourceSelectStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9038:1: ( rule__SingleSourceSelectStatement__Group__1__Impl rule__SingleSourceSelectStatement__Group__2 )
            // InternalMickeyLang.g:9039:2: rule__SingleSourceSelectStatement__Group__1__Impl rule__SingleSourceSelectStatement__Group__2
            {
            pushFollow(FOLLOW_54);
            rule__SingleSourceSelectStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__1"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__1__Impl"
    // InternalMickeyLang.g:9046:1: rule__SingleSourceSelectStatement__Group__1__Impl : ( '(' ) ;
    public final void rule__SingleSourceSelectStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9050:1: ( ( '(' ) )
            // InternalMickeyLang.g:9051:1: ( '(' )
            {
            // InternalMickeyLang.g:9051:1: ( '(' )
            // InternalMickeyLang.g:9052:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getLeftParenthesisKeyword_1()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getLeftParenthesisKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__1__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__2"
    // InternalMickeyLang.g:9061:1: rule__SingleSourceSelectStatement__Group__2 : rule__SingleSourceSelectStatement__Group__2__Impl rule__SingleSourceSelectStatement__Group__3 ;
    public final void rule__SingleSourceSelectStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9065:1: ( rule__SingleSourceSelectStatement__Group__2__Impl rule__SingleSourceSelectStatement__Group__3 )
            // InternalMickeyLang.g:9066:2: rule__SingleSourceSelectStatement__Group__2__Impl rule__SingleSourceSelectStatement__Group__3
            {
            pushFollow(FOLLOW_52);
            rule__SingleSourceSelectStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__2"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__2__Impl"
    // InternalMickeyLang.g:9073:1: rule__SingleSourceSelectStatement__Group__2__Impl : ( ( rule__SingleSourceSelectStatement__SelectStatementAssignment_2 ) ) ;
    public final void rule__SingleSourceSelectStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9077:1: ( ( ( rule__SingleSourceSelectStatement__SelectStatementAssignment_2 ) ) )
            // InternalMickeyLang.g:9078:1: ( ( rule__SingleSourceSelectStatement__SelectStatementAssignment_2 ) )
            {
            // InternalMickeyLang.g:9078:1: ( ( rule__SingleSourceSelectStatement__SelectStatementAssignment_2 ) )
            // InternalMickeyLang.g:9079:2: ( rule__SingleSourceSelectStatement__SelectStatementAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getSelectStatementAssignment_2()); 
            }
            // InternalMickeyLang.g:9080:2: ( rule__SingleSourceSelectStatement__SelectStatementAssignment_2 )
            // InternalMickeyLang.g:9080:3: rule__SingleSourceSelectStatement__SelectStatementAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__SelectStatementAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getSelectStatementAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__2__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__3"
    // InternalMickeyLang.g:9088:1: rule__SingleSourceSelectStatement__Group__3 : rule__SingleSourceSelectStatement__Group__3__Impl rule__SingleSourceSelectStatement__Group__4 ;
    public final void rule__SingleSourceSelectStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9092:1: ( rule__SingleSourceSelectStatement__Group__3__Impl rule__SingleSourceSelectStatement__Group__4 )
            // InternalMickeyLang.g:9093:2: rule__SingleSourceSelectStatement__Group__3__Impl rule__SingleSourceSelectStatement__Group__4
            {
            pushFollow(FOLLOW_61);
            rule__SingleSourceSelectStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__3"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__3__Impl"
    // InternalMickeyLang.g:9100:1: rule__SingleSourceSelectStatement__Group__3__Impl : ( ')' ) ;
    public final void rule__SingleSourceSelectStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9104:1: ( ( ')' ) )
            // InternalMickeyLang.g:9105:1: ( ')' )
            {
            // InternalMickeyLang.g:9105:1: ( ')' )
            // InternalMickeyLang.g:9106:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getRightParenthesisKeyword_3()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getRightParenthesisKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__3__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__4"
    // InternalMickeyLang.g:9115:1: rule__SingleSourceSelectStatement__Group__4 : rule__SingleSourceSelectStatement__Group__4__Impl ;
    public final void rule__SingleSourceSelectStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9119:1: ( rule__SingleSourceSelectStatement__Group__4__Impl )
            // InternalMickeyLang.g:9120:2: rule__SingleSourceSelectStatement__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__4"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group__4__Impl"
    // InternalMickeyLang.g:9126:1: rule__SingleSourceSelectStatement__Group__4__Impl : ( ( rule__SingleSourceSelectStatement__Group_4__0 )? ) ;
    public final void rule__SingleSourceSelectStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9130:1: ( ( ( rule__SingleSourceSelectStatement__Group_4__0 )? ) )
            // InternalMickeyLang.g:9131:1: ( ( rule__SingleSourceSelectStatement__Group_4__0 )? )
            {
            // InternalMickeyLang.g:9131:1: ( ( rule__SingleSourceSelectStatement__Group_4__0 )? )
            // InternalMickeyLang.g:9132:2: ( rule__SingleSourceSelectStatement__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getGroup_4()); 
            }
            // InternalMickeyLang.g:9133:2: ( rule__SingleSourceSelectStatement__Group_4__0 )?
            int alt84=2;
            int LA84_0 = input.LA(1);

            if ( (LA84_0==82) ) {
                alt84=1;
            }
            switch (alt84) {
                case 1 :
                    // InternalMickeyLang.g:9133:3: rule__SingleSourceSelectStatement__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__SingleSourceSelectStatement__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getGroup_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group__4__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group_4__0"
    // InternalMickeyLang.g:9142:1: rule__SingleSourceSelectStatement__Group_4__0 : rule__SingleSourceSelectStatement__Group_4__0__Impl rule__SingleSourceSelectStatement__Group_4__1 ;
    public final void rule__SingleSourceSelectStatement__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9146:1: ( rule__SingleSourceSelectStatement__Group_4__0__Impl rule__SingleSourceSelectStatement__Group_4__1 )
            // InternalMickeyLang.g:9147:2: rule__SingleSourceSelectStatement__Group_4__0__Impl rule__SingleSourceSelectStatement__Group_4__1
            {
            pushFollow(FOLLOW_3);
            rule__SingleSourceSelectStatement__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group_4__0"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group_4__0__Impl"
    // InternalMickeyLang.g:9154:1: rule__SingleSourceSelectStatement__Group_4__0__Impl : ( 'as' ) ;
    public final void rule__SingleSourceSelectStatement__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9158:1: ( ( 'as' ) )
            // InternalMickeyLang.g:9159:1: ( 'as' )
            {
            // InternalMickeyLang.g:9159:1: ( 'as' )
            // InternalMickeyLang.g:9160:2: 'as'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getAsKeyword_4_0()); 
            }
            match(input,82,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getAsKeyword_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group_4__0__Impl"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group_4__1"
    // InternalMickeyLang.g:9169:1: rule__SingleSourceSelectStatement__Group_4__1 : rule__SingleSourceSelectStatement__Group_4__1__Impl ;
    public final void rule__SingleSourceSelectStatement__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9173:1: ( rule__SingleSourceSelectStatement__Group_4__1__Impl )
            // InternalMickeyLang.g:9174:2: rule__SingleSourceSelectStatement__Group_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group_4__1"


    // $ANTLR start "rule__SingleSourceSelectStatement__Group_4__1__Impl"
    // InternalMickeyLang.g:9180:1: rule__SingleSourceSelectStatement__Group_4__1__Impl : ( ( rule__SingleSourceSelectStatement__NameAssignment_4_1 ) ) ;
    public final void rule__SingleSourceSelectStatement__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9184:1: ( ( ( rule__SingleSourceSelectStatement__NameAssignment_4_1 ) ) )
            // InternalMickeyLang.g:9185:1: ( ( rule__SingleSourceSelectStatement__NameAssignment_4_1 ) )
            {
            // InternalMickeyLang.g:9185:1: ( ( rule__SingleSourceSelectStatement__NameAssignment_4_1 ) )
            // InternalMickeyLang.g:9186:2: ( rule__SingleSourceSelectStatement__NameAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getNameAssignment_4_1()); 
            }
            // InternalMickeyLang.g:9187:2: ( rule__SingleSourceSelectStatement__NameAssignment_4_1 )
            // InternalMickeyLang.g:9187:3: rule__SingleSourceSelectStatement__NameAssignment_4_1
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceSelectStatement__NameAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getNameAssignment_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__Group_4__1__Impl"


    // $ANTLR start "rule__SingleSourceJoin__Group__0"
    // InternalMickeyLang.g:9196:1: rule__SingleSourceJoin__Group__0 : rule__SingleSourceJoin__Group__0__Impl rule__SingleSourceJoin__Group__1 ;
    public final void rule__SingleSourceJoin__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9200:1: ( rule__SingleSourceJoin__Group__0__Impl rule__SingleSourceJoin__Group__1 )
            // InternalMickeyLang.g:9201:2: rule__SingleSourceJoin__Group__0__Impl rule__SingleSourceJoin__Group__1
            {
            pushFollow(FOLLOW_70);
            rule__SingleSourceJoin__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceJoin__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__Group__0"


    // $ANTLR start "rule__SingleSourceJoin__Group__0__Impl"
    // InternalMickeyLang.g:9208:1: rule__SingleSourceJoin__Group__0__Impl : ( '(' ) ;
    public final void rule__SingleSourceJoin__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9212:1: ( ( '(' ) )
            // InternalMickeyLang.g:9213:1: ( '(' )
            {
            // InternalMickeyLang.g:9213:1: ( '(' )
            // InternalMickeyLang.g:9214:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceJoinAccess().getLeftParenthesisKeyword_0()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceJoinAccess().getLeftParenthesisKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__Group__0__Impl"


    // $ANTLR start "rule__SingleSourceJoin__Group__1"
    // InternalMickeyLang.g:9223:1: rule__SingleSourceJoin__Group__1 : rule__SingleSourceJoin__Group__1__Impl rule__SingleSourceJoin__Group__2 ;
    public final void rule__SingleSourceJoin__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9227:1: ( rule__SingleSourceJoin__Group__1__Impl rule__SingleSourceJoin__Group__2 )
            // InternalMickeyLang.g:9228:2: rule__SingleSourceJoin__Group__1__Impl rule__SingleSourceJoin__Group__2
            {
            pushFollow(FOLLOW_52);
            rule__SingleSourceJoin__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SingleSourceJoin__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__Group__1"


    // $ANTLR start "rule__SingleSourceJoin__Group__1__Impl"
    // InternalMickeyLang.g:9235:1: rule__SingleSourceJoin__Group__1__Impl : ( ( rule__SingleSourceJoin__JoinSourceAssignment_1 ) ) ;
    public final void rule__SingleSourceJoin__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9239:1: ( ( ( rule__SingleSourceJoin__JoinSourceAssignment_1 ) ) )
            // InternalMickeyLang.g:9240:1: ( ( rule__SingleSourceJoin__JoinSourceAssignment_1 ) )
            {
            // InternalMickeyLang.g:9240:1: ( ( rule__SingleSourceJoin__JoinSourceAssignment_1 ) )
            // InternalMickeyLang.g:9241:2: ( rule__SingleSourceJoin__JoinSourceAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceJoinAccess().getJoinSourceAssignment_1()); 
            }
            // InternalMickeyLang.g:9242:2: ( rule__SingleSourceJoin__JoinSourceAssignment_1 )
            // InternalMickeyLang.g:9242:3: rule__SingleSourceJoin__JoinSourceAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceJoin__JoinSourceAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceJoinAccess().getJoinSourceAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__Group__1__Impl"


    // $ANTLR start "rule__SingleSourceJoin__Group__2"
    // InternalMickeyLang.g:9250:1: rule__SingleSourceJoin__Group__2 : rule__SingleSourceJoin__Group__2__Impl ;
    public final void rule__SingleSourceJoin__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9254:1: ( rule__SingleSourceJoin__Group__2__Impl )
            // InternalMickeyLang.g:9255:2: rule__SingleSourceJoin__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SingleSourceJoin__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__Group__2"


    // $ANTLR start "rule__SingleSourceJoin__Group__2__Impl"
    // InternalMickeyLang.g:9261:1: rule__SingleSourceJoin__Group__2__Impl : ( ')' ) ;
    public final void rule__SingleSourceJoin__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9265:1: ( ( ')' ) )
            // InternalMickeyLang.g:9266:1: ( ')' )
            {
            // InternalMickeyLang.g:9266:1: ( ')' )
            // InternalMickeyLang.g:9267:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceJoinAccess().getRightParenthesisKeyword_2()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceJoinAccess().getRightParenthesisKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__Group__2__Impl"


    // $ANTLR start "rule__JoinStatement__Group__0"
    // InternalMickeyLang.g:9277:1: rule__JoinStatement__Group__0 : rule__JoinStatement__Group__0__Impl rule__JoinStatement__Group__1 ;
    public final void rule__JoinStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9281:1: ( rule__JoinStatement__Group__0__Impl rule__JoinStatement__Group__1 )
            // InternalMickeyLang.g:9282:2: rule__JoinStatement__Group__0__Impl rule__JoinStatement__Group__1
            {
            pushFollow(FOLLOW_72);
            rule__JoinStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__0"


    // $ANTLR start "rule__JoinStatement__Group__0__Impl"
    // InternalMickeyLang.g:9289:1: rule__JoinStatement__Group__0__Impl : ( () ) ;
    public final void rule__JoinStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9293:1: ( ( () ) )
            // InternalMickeyLang.g:9294:1: ( () )
            {
            // InternalMickeyLang.g:9294:1: ( () )
            // InternalMickeyLang.g:9295:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getJoinStatementAction_0()); 
            }
            // InternalMickeyLang.g:9296:2: ()
            // InternalMickeyLang.g:9296:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getJoinStatementAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__0__Impl"


    // $ANTLR start "rule__JoinStatement__Group__1"
    // InternalMickeyLang.g:9304:1: rule__JoinStatement__Group__1 : rule__JoinStatement__Group__1__Impl rule__JoinStatement__Group__2 ;
    public final void rule__JoinStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9308:1: ( rule__JoinStatement__Group__1__Impl rule__JoinStatement__Group__2 )
            // InternalMickeyLang.g:9309:2: rule__JoinStatement__Group__1__Impl rule__JoinStatement__Group__2
            {
            pushFollow(FOLLOW_72);
            rule__JoinStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__1"


    // $ANTLR start "rule__JoinStatement__Group__1__Impl"
    // InternalMickeyLang.g:9316:1: rule__JoinStatement__Group__1__Impl : ( ( rule__JoinStatement__NaturalAssignment_1 )? ) ;
    public final void rule__JoinStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9320:1: ( ( ( rule__JoinStatement__NaturalAssignment_1 )? ) )
            // InternalMickeyLang.g:9321:1: ( ( rule__JoinStatement__NaturalAssignment_1 )? )
            {
            // InternalMickeyLang.g:9321:1: ( ( rule__JoinStatement__NaturalAssignment_1 )? )
            // InternalMickeyLang.g:9322:2: ( rule__JoinStatement__NaturalAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getNaturalAssignment_1()); 
            }
            // InternalMickeyLang.g:9323:2: ( rule__JoinStatement__NaturalAssignment_1 )?
            int alt85=2;
            int LA85_0 = input.LA(1);

            if ( (LA85_0==126) ) {
                alt85=1;
            }
            switch (alt85) {
                case 1 :
                    // InternalMickeyLang.g:9323:3: rule__JoinStatement__NaturalAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__JoinStatement__NaturalAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getNaturalAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__1__Impl"


    // $ANTLR start "rule__JoinStatement__Group__2"
    // InternalMickeyLang.g:9331:1: rule__JoinStatement__Group__2 : rule__JoinStatement__Group__2__Impl rule__JoinStatement__Group__3 ;
    public final void rule__JoinStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9335:1: ( rule__JoinStatement__Group__2__Impl rule__JoinStatement__Group__3 )
            // InternalMickeyLang.g:9336:2: rule__JoinStatement__Group__2__Impl rule__JoinStatement__Group__3
            {
            pushFollow(FOLLOW_72);
            rule__JoinStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__2"


    // $ANTLR start "rule__JoinStatement__Group__2__Impl"
    // InternalMickeyLang.g:9343:1: rule__JoinStatement__Group__2__Impl : ( ( rule__JoinStatement__Alternatives_2 )? ) ;
    public final void rule__JoinStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9347:1: ( ( ( rule__JoinStatement__Alternatives_2 )? ) )
            // InternalMickeyLang.g:9348:1: ( ( rule__JoinStatement__Alternatives_2 )? )
            {
            // InternalMickeyLang.g:9348:1: ( ( rule__JoinStatement__Alternatives_2 )? )
            // InternalMickeyLang.g:9349:2: ( rule__JoinStatement__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getAlternatives_2()); 
            }
            // InternalMickeyLang.g:9350:2: ( rule__JoinStatement__Alternatives_2 )?
            int alt86=2;
            int LA86_0 = input.LA(1);

            if ( (LA86_0==127||(LA86_0>=129 && LA86_0<=130)) ) {
                alt86=1;
            }
            switch (alt86) {
                case 1 :
                    // InternalMickeyLang.g:9350:3: rule__JoinStatement__Alternatives_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__JoinStatement__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getAlternatives_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__2__Impl"


    // $ANTLR start "rule__JoinStatement__Group__3"
    // InternalMickeyLang.g:9358:1: rule__JoinStatement__Group__3 : rule__JoinStatement__Group__3__Impl rule__JoinStatement__Group__4 ;
    public final void rule__JoinStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9362:1: ( rule__JoinStatement__Group__3__Impl rule__JoinStatement__Group__4 )
            // InternalMickeyLang.g:9363:2: rule__JoinStatement__Group__3__Impl rule__JoinStatement__Group__4
            {
            pushFollow(FOLLOW_70);
            rule__JoinStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__3"


    // $ANTLR start "rule__JoinStatement__Group__3__Impl"
    // InternalMickeyLang.g:9370:1: rule__JoinStatement__Group__3__Impl : ( 'join' ) ;
    public final void rule__JoinStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9374:1: ( ( 'join' ) )
            // InternalMickeyLang.g:9375:1: ( 'join' )
            {
            // InternalMickeyLang.g:9375:1: ( 'join' )
            // InternalMickeyLang.g:9376:2: 'join'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getJoinKeyword_3()); 
            }
            match(input,92,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getJoinKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__3__Impl"


    // $ANTLR start "rule__JoinStatement__Group__4"
    // InternalMickeyLang.g:9385:1: rule__JoinStatement__Group__4 : rule__JoinStatement__Group__4__Impl rule__JoinStatement__Group__5 ;
    public final void rule__JoinStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9389:1: ( rule__JoinStatement__Group__4__Impl rule__JoinStatement__Group__5 )
            // InternalMickeyLang.g:9390:2: rule__JoinStatement__Group__4__Impl rule__JoinStatement__Group__5
            {
            pushFollow(FOLLOW_16);
            rule__JoinStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__4"


    // $ANTLR start "rule__JoinStatement__Group__4__Impl"
    // InternalMickeyLang.g:9397:1: rule__JoinStatement__Group__4__Impl : ( ( rule__JoinStatement__SingleSourceAssignment_4 ) ) ;
    public final void rule__JoinStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9401:1: ( ( ( rule__JoinStatement__SingleSourceAssignment_4 ) ) )
            // InternalMickeyLang.g:9402:1: ( ( rule__JoinStatement__SingleSourceAssignment_4 ) )
            {
            // InternalMickeyLang.g:9402:1: ( ( rule__JoinStatement__SingleSourceAssignment_4 ) )
            // InternalMickeyLang.g:9403:2: ( rule__JoinStatement__SingleSourceAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getSingleSourceAssignment_4()); 
            }
            // InternalMickeyLang.g:9404:2: ( rule__JoinStatement__SingleSourceAssignment_4 )
            // InternalMickeyLang.g:9404:3: rule__JoinStatement__SingleSourceAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__JoinStatement__SingleSourceAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getSingleSourceAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__4__Impl"


    // $ANTLR start "rule__JoinStatement__Group__5"
    // InternalMickeyLang.g:9412:1: rule__JoinStatement__Group__5 : rule__JoinStatement__Group__5__Impl rule__JoinStatement__Group__6 ;
    public final void rule__JoinStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9416:1: ( rule__JoinStatement__Group__5__Impl rule__JoinStatement__Group__6 )
            // InternalMickeyLang.g:9417:2: rule__JoinStatement__Group__5__Impl rule__JoinStatement__Group__6
            {
            pushFollow(FOLLOW_30);
            rule__JoinStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__5"


    // $ANTLR start "rule__JoinStatement__Group__5__Impl"
    // InternalMickeyLang.g:9424:1: rule__JoinStatement__Group__5__Impl : ( 'on' ) ;
    public final void rule__JoinStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9428:1: ( ( 'on' ) )
            // InternalMickeyLang.g:9429:1: ( 'on' )
            {
            // InternalMickeyLang.g:9429:1: ( 'on' )
            // InternalMickeyLang.g:9430:2: 'on'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getOnKeyword_5()); 
            }
            match(input,69,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getOnKeyword_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__5__Impl"


    // $ANTLR start "rule__JoinStatement__Group__6"
    // InternalMickeyLang.g:9439:1: rule__JoinStatement__Group__6 : rule__JoinStatement__Group__6__Impl ;
    public final void rule__JoinStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9443:1: ( rule__JoinStatement__Group__6__Impl )
            // InternalMickeyLang.g:9444:2: rule__JoinStatement__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__6"


    // $ANTLR start "rule__JoinStatement__Group__6__Impl"
    // InternalMickeyLang.g:9450:1: rule__JoinStatement__Group__6__Impl : ( ( rule__JoinStatement__ExpressionAssignment_6 ) ) ;
    public final void rule__JoinStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9454:1: ( ( ( rule__JoinStatement__ExpressionAssignment_6 ) ) )
            // InternalMickeyLang.g:9455:1: ( ( rule__JoinStatement__ExpressionAssignment_6 ) )
            {
            // InternalMickeyLang.g:9455:1: ( ( rule__JoinStatement__ExpressionAssignment_6 ) )
            // InternalMickeyLang.g:9456:2: ( rule__JoinStatement__ExpressionAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getExpressionAssignment_6()); 
            }
            // InternalMickeyLang.g:9457:2: ( rule__JoinStatement__ExpressionAssignment_6 )
            // InternalMickeyLang.g:9457:3: rule__JoinStatement__ExpressionAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__JoinStatement__ExpressionAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getExpressionAssignment_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group__6__Impl"


    // $ANTLR start "rule__JoinStatement__Group_2_0__0"
    // InternalMickeyLang.g:9466:1: rule__JoinStatement__Group_2_0__0 : rule__JoinStatement__Group_2_0__0__Impl rule__JoinStatement__Group_2_0__1 ;
    public final void rule__JoinStatement__Group_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9470:1: ( rule__JoinStatement__Group_2_0__0__Impl rule__JoinStatement__Group_2_0__1 )
            // InternalMickeyLang.g:9471:2: rule__JoinStatement__Group_2_0__0__Impl rule__JoinStatement__Group_2_0__1
            {
            pushFollow(FOLLOW_74);
            rule__JoinStatement__Group_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group_2_0__0"


    // $ANTLR start "rule__JoinStatement__Group_2_0__0__Impl"
    // InternalMickeyLang.g:9478:1: rule__JoinStatement__Group_2_0__0__Impl : ( ( rule__JoinStatement__LeftAssignment_2_0_0 ) ) ;
    public final void rule__JoinStatement__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9482:1: ( ( ( rule__JoinStatement__LeftAssignment_2_0_0 ) ) )
            // InternalMickeyLang.g:9483:1: ( ( rule__JoinStatement__LeftAssignment_2_0_0 ) )
            {
            // InternalMickeyLang.g:9483:1: ( ( rule__JoinStatement__LeftAssignment_2_0_0 ) )
            // InternalMickeyLang.g:9484:2: ( rule__JoinStatement__LeftAssignment_2_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getLeftAssignment_2_0_0()); 
            }
            // InternalMickeyLang.g:9485:2: ( rule__JoinStatement__LeftAssignment_2_0_0 )
            // InternalMickeyLang.g:9485:3: rule__JoinStatement__LeftAssignment_2_0_0
            {
            pushFollow(FOLLOW_2);
            rule__JoinStatement__LeftAssignment_2_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getLeftAssignment_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group_2_0__0__Impl"


    // $ANTLR start "rule__JoinStatement__Group_2_0__1"
    // InternalMickeyLang.g:9493:1: rule__JoinStatement__Group_2_0__1 : rule__JoinStatement__Group_2_0__1__Impl ;
    public final void rule__JoinStatement__Group_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9497:1: ( rule__JoinStatement__Group_2_0__1__Impl )
            // InternalMickeyLang.g:9498:2: rule__JoinStatement__Group_2_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__JoinStatement__Group_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group_2_0__1"


    // $ANTLR start "rule__JoinStatement__Group_2_0__1__Impl"
    // InternalMickeyLang.g:9504:1: rule__JoinStatement__Group_2_0__1__Impl : ( ( rule__JoinStatement__OuterAssignment_2_0_1 )? ) ;
    public final void rule__JoinStatement__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9508:1: ( ( ( rule__JoinStatement__OuterAssignment_2_0_1 )? ) )
            // InternalMickeyLang.g:9509:1: ( ( rule__JoinStatement__OuterAssignment_2_0_1 )? )
            {
            // InternalMickeyLang.g:9509:1: ( ( rule__JoinStatement__OuterAssignment_2_0_1 )? )
            // InternalMickeyLang.g:9510:2: ( rule__JoinStatement__OuterAssignment_2_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getOuterAssignment_2_0_1()); 
            }
            // InternalMickeyLang.g:9511:2: ( rule__JoinStatement__OuterAssignment_2_0_1 )?
            int alt87=2;
            int LA87_0 = input.LA(1);

            if ( (LA87_0==128) ) {
                alt87=1;
            }
            switch (alt87) {
                case 1 :
                    // InternalMickeyLang.g:9511:3: rule__JoinStatement__OuterAssignment_2_0_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__JoinStatement__OuterAssignment_2_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getOuterAssignment_2_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__Group_2_0__1__Impl"


    // $ANTLR start "rule__ResultColumn__Group__0"
    // InternalMickeyLang.g:9520:1: rule__ResultColumn__Group__0 : rule__ResultColumn__Group__0__Impl rule__ResultColumn__Group__1 ;
    public final void rule__ResultColumn__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9524:1: ( rule__ResultColumn__Group__0__Impl rule__ResultColumn__Group__1 )
            // InternalMickeyLang.g:9525:2: rule__ResultColumn__Group__0__Impl rule__ResultColumn__Group__1
            {
            pushFollow(FOLLOW_68);
            rule__ResultColumn__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ResultColumn__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group__0"


    // $ANTLR start "rule__ResultColumn__Group__0__Impl"
    // InternalMickeyLang.g:9532:1: rule__ResultColumn__Group__0__Impl : ( () ) ;
    public final void rule__ResultColumn__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9536:1: ( ( () ) )
            // InternalMickeyLang.g:9537:1: ( () )
            {
            // InternalMickeyLang.g:9537:1: ( () )
            // InternalMickeyLang.g:9538:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getResultColumnAction_0()); 
            }
            // InternalMickeyLang.g:9539:2: ()
            // InternalMickeyLang.g:9539:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getResultColumnAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group__0__Impl"


    // $ANTLR start "rule__ResultColumn__Group__1"
    // InternalMickeyLang.g:9547:1: rule__ResultColumn__Group__1 : rule__ResultColumn__Group__1__Impl rule__ResultColumn__Group__2 ;
    public final void rule__ResultColumn__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9551:1: ( rule__ResultColumn__Group__1__Impl rule__ResultColumn__Group__2 )
            // InternalMickeyLang.g:9552:2: rule__ResultColumn__Group__1__Impl rule__ResultColumn__Group__2
            {
            pushFollow(FOLLOW_61);
            rule__ResultColumn__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ResultColumn__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group__1"


    // $ANTLR start "rule__ResultColumn__Group__1__Impl"
    // InternalMickeyLang.g:9559:1: rule__ResultColumn__Group__1__Impl : ( ( rule__ResultColumn__ExpressionAssignment_1 ) ) ;
    public final void rule__ResultColumn__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9563:1: ( ( ( rule__ResultColumn__ExpressionAssignment_1 ) ) )
            // InternalMickeyLang.g:9564:1: ( ( rule__ResultColumn__ExpressionAssignment_1 ) )
            {
            // InternalMickeyLang.g:9564:1: ( ( rule__ResultColumn__ExpressionAssignment_1 ) )
            // InternalMickeyLang.g:9565:2: ( rule__ResultColumn__ExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getExpressionAssignment_1()); 
            }
            // InternalMickeyLang.g:9566:2: ( rule__ResultColumn__ExpressionAssignment_1 )
            // InternalMickeyLang.g:9566:3: rule__ResultColumn__ExpressionAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ResultColumn__ExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getExpressionAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group__1__Impl"


    // $ANTLR start "rule__ResultColumn__Group__2"
    // InternalMickeyLang.g:9574:1: rule__ResultColumn__Group__2 : rule__ResultColumn__Group__2__Impl ;
    public final void rule__ResultColumn__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9578:1: ( rule__ResultColumn__Group__2__Impl )
            // InternalMickeyLang.g:9579:2: rule__ResultColumn__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ResultColumn__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group__2"


    // $ANTLR start "rule__ResultColumn__Group__2__Impl"
    // InternalMickeyLang.g:9585:1: rule__ResultColumn__Group__2__Impl : ( ( rule__ResultColumn__Group_2__0 )? ) ;
    public final void rule__ResultColumn__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9589:1: ( ( ( rule__ResultColumn__Group_2__0 )? ) )
            // InternalMickeyLang.g:9590:1: ( ( rule__ResultColumn__Group_2__0 )? )
            {
            // InternalMickeyLang.g:9590:1: ( ( rule__ResultColumn__Group_2__0 )? )
            // InternalMickeyLang.g:9591:2: ( rule__ResultColumn__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getGroup_2()); 
            }
            // InternalMickeyLang.g:9592:2: ( rule__ResultColumn__Group_2__0 )?
            int alt88=2;
            int LA88_0 = input.LA(1);

            if ( (LA88_0==82) ) {
                alt88=1;
            }
            switch (alt88) {
                case 1 :
                    // InternalMickeyLang.g:9592:3: rule__ResultColumn__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ResultColumn__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getGroup_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group__2__Impl"


    // $ANTLR start "rule__ResultColumn__Group_2__0"
    // InternalMickeyLang.g:9601:1: rule__ResultColumn__Group_2__0 : rule__ResultColumn__Group_2__0__Impl rule__ResultColumn__Group_2__1 ;
    public final void rule__ResultColumn__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9605:1: ( rule__ResultColumn__Group_2__0__Impl rule__ResultColumn__Group_2__1 )
            // InternalMickeyLang.g:9606:2: rule__ResultColumn__Group_2__0__Impl rule__ResultColumn__Group_2__1
            {
            pushFollow(FOLLOW_3);
            rule__ResultColumn__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ResultColumn__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group_2__0"


    // $ANTLR start "rule__ResultColumn__Group_2__0__Impl"
    // InternalMickeyLang.g:9613:1: rule__ResultColumn__Group_2__0__Impl : ( 'as' ) ;
    public final void rule__ResultColumn__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9617:1: ( ( 'as' ) )
            // InternalMickeyLang.g:9618:1: ( 'as' )
            {
            // InternalMickeyLang.g:9618:1: ( 'as' )
            // InternalMickeyLang.g:9619:2: 'as'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getAsKeyword_2_0()); 
            }
            match(input,82,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getAsKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group_2__0__Impl"


    // $ANTLR start "rule__ResultColumn__Group_2__1"
    // InternalMickeyLang.g:9628:1: rule__ResultColumn__Group_2__1 : rule__ResultColumn__Group_2__1__Impl ;
    public final void rule__ResultColumn__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9632:1: ( rule__ResultColumn__Group_2__1__Impl )
            // InternalMickeyLang.g:9633:2: rule__ResultColumn__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ResultColumn__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group_2__1"


    // $ANTLR start "rule__ResultColumn__Group_2__1__Impl"
    // InternalMickeyLang.g:9639:1: rule__ResultColumn__Group_2__1__Impl : ( ( rule__ResultColumn__NameAssignment_2_1 ) ) ;
    public final void rule__ResultColumn__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9643:1: ( ( ( rule__ResultColumn__NameAssignment_2_1 ) ) )
            // InternalMickeyLang.g:9644:1: ( ( rule__ResultColumn__NameAssignment_2_1 ) )
            {
            // InternalMickeyLang.g:9644:1: ( ( rule__ResultColumn__NameAssignment_2_1 ) )
            // InternalMickeyLang.g:9645:2: ( rule__ResultColumn__NameAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getNameAssignment_2_1()); 
            }
            // InternalMickeyLang.g:9646:2: ( rule__ResultColumn__NameAssignment_2_1 )
            // InternalMickeyLang.g:9646:3: rule__ResultColumn__NameAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__ResultColumn__NameAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getNameAssignment_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__Group_2__1__Impl"


    // $ANTLR start "rule__LiteralValue__Group_0__0"
    // InternalMickeyLang.g:9655:1: rule__LiteralValue__Group_0__0 : rule__LiteralValue__Group_0__0__Impl rule__LiteralValue__Group_0__1 ;
    public final void rule__LiteralValue__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9659:1: ( rule__LiteralValue__Group_0__0__Impl rule__LiteralValue__Group_0__1 )
            // InternalMickeyLang.g:9660:2: rule__LiteralValue__Group_0__0__Impl rule__LiteralValue__Group_0__1
            {
            pushFollow(FOLLOW_75);
            rule__LiteralValue__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_0__0"


    // $ANTLR start "rule__LiteralValue__Group_0__0__Impl"
    // InternalMickeyLang.g:9667:1: rule__LiteralValue__Group_0__0__Impl : ( () ) ;
    public final void rule__LiteralValue__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9671:1: ( ( () ) )
            // InternalMickeyLang.g:9672:1: ( () )
            {
            // InternalMickeyLang.g:9672:1: ( () )
            // InternalMickeyLang.g:9673:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getNumericLiteralAction_0_0()); 
            }
            // InternalMickeyLang.g:9674:2: ()
            // InternalMickeyLang.g:9674:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getNumericLiteralAction_0_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_0__0__Impl"


    // $ANTLR start "rule__LiteralValue__Group_0__1"
    // InternalMickeyLang.g:9682:1: rule__LiteralValue__Group_0__1 : rule__LiteralValue__Group_0__1__Impl ;
    public final void rule__LiteralValue__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9686:1: ( rule__LiteralValue__Group_0__1__Impl )
            // InternalMickeyLang.g:9687:2: rule__LiteralValue__Group_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_0__1"


    // $ANTLR start "rule__LiteralValue__Group_0__1__Impl"
    // InternalMickeyLang.g:9693:1: rule__LiteralValue__Group_0__1__Impl : ( ( rule__LiteralValue__NumberAssignment_0_1 ) ) ;
    public final void rule__LiteralValue__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9697:1: ( ( ( rule__LiteralValue__NumberAssignment_0_1 ) ) )
            // InternalMickeyLang.g:9698:1: ( ( rule__LiteralValue__NumberAssignment_0_1 ) )
            {
            // InternalMickeyLang.g:9698:1: ( ( rule__LiteralValue__NumberAssignment_0_1 ) )
            // InternalMickeyLang.g:9699:2: ( rule__LiteralValue__NumberAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getNumberAssignment_0_1()); 
            }
            // InternalMickeyLang.g:9700:2: ( rule__LiteralValue__NumberAssignment_0_1 )
            // InternalMickeyLang.g:9700:3: rule__LiteralValue__NumberAssignment_0_1
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__NumberAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getNumberAssignment_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_0__1__Impl"


    // $ANTLR start "rule__LiteralValue__Group_1__0"
    // InternalMickeyLang.g:9709:1: rule__LiteralValue__Group_1__0 : rule__LiteralValue__Group_1__0__Impl rule__LiteralValue__Group_1__1 ;
    public final void rule__LiteralValue__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9713:1: ( rule__LiteralValue__Group_1__0__Impl rule__LiteralValue__Group_1__1 )
            // InternalMickeyLang.g:9714:2: rule__LiteralValue__Group_1__0__Impl rule__LiteralValue__Group_1__1
            {
            pushFollow(FOLLOW_76);
            rule__LiteralValue__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_1__0"


    // $ANTLR start "rule__LiteralValue__Group_1__0__Impl"
    // InternalMickeyLang.g:9721:1: rule__LiteralValue__Group_1__0__Impl : ( () ) ;
    public final void rule__LiteralValue__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9725:1: ( ( () ) )
            // InternalMickeyLang.g:9726:1: ( () )
            {
            // InternalMickeyLang.g:9726:1: ( () )
            // InternalMickeyLang.g:9727:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getStringLiteralAction_1_0()); 
            }
            // InternalMickeyLang.g:9728:2: ()
            // InternalMickeyLang.g:9728:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getStringLiteralAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_1__0__Impl"


    // $ANTLR start "rule__LiteralValue__Group_1__1"
    // InternalMickeyLang.g:9736:1: rule__LiteralValue__Group_1__1 : rule__LiteralValue__Group_1__1__Impl ;
    public final void rule__LiteralValue__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9740:1: ( rule__LiteralValue__Group_1__1__Impl )
            // InternalMickeyLang.g:9741:2: rule__LiteralValue__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_1__1"


    // $ANTLR start "rule__LiteralValue__Group_1__1__Impl"
    // InternalMickeyLang.g:9747:1: rule__LiteralValue__Group_1__1__Impl : ( ( rule__LiteralValue__LiteralAssignment_1_1 ) ) ;
    public final void rule__LiteralValue__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9751:1: ( ( ( rule__LiteralValue__LiteralAssignment_1_1 ) ) )
            // InternalMickeyLang.g:9752:1: ( ( rule__LiteralValue__LiteralAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:9752:1: ( ( rule__LiteralValue__LiteralAssignment_1_1 ) )
            // InternalMickeyLang.g:9753:2: ( rule__LiteralValue__LiteralAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralAssignment_1_1()); 
            }
            // InternalMickeyLang.g:9754:2: ( rule__LiteralValue__LiteralAssignment_1_1 )
            // InternalMickeyLang.g:9754:3: rule__LiteralValue__LiteralAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__LiteralAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_1__1__Impl"


    // $ANTLR start "rule__LiteralValue__Group_2__0"
    // InternalMickeyLang.g:9763:1: rule__LiteralValue__Group_2__0 : rule__LiteralValue__Group_2__0__Impl rule__LiteralValue__Group_2__1 ;
    public final void rule__LiteralValue__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9767:1: ( rule__LiteralValue__Group_2__0__Impl rule__LiteralValue__Group_2__1 )
            // InternalMickeyLang.g:9768:2: rule__LiteralValue__Group_2__0__Impl rule__LiteralValue__Group_2__1
            {
            pushFollow(FOLLOW_77);
            rule__LiteralValue__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_2__0"


    // $ANTLR start "rule__LiteralValue__Group_2__0__Impl"
    // InternalMickeyLang.g:9775:1: rule__LiteralValue__Group_2__0__Impl : ( () ) ;
    public final void rule__LiteralValue__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9779:1: ( ( () ) )
            // InternalMickeyLang.g:9780:1: ( () )
            {
            // InternalMickeyLang.g:9780:1: ( () )
            // InternalMickeyLang.g:9781:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getNullLiteralAction_2_0()); 
            }
            // InternalMickeyLang.g:9782:2: ()
            // InternalMickeyLang.g:9782:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getNullLiteralAction_2_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_2__0__Impl"


    // $ANTLR start "rule__LiteralValue__Group_2__1"
    // InternalMickeyLang.g:9790:1: rule__LiteralValue__Group_2__1 : rule__LiteralValue__Group_2__1__Impl ;
    public final void rule__LiteralValue__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9794:1: ( rule__LiteralValue__Group_2__1__Impl )
            // InternalMickeyLang.g:9795:2: rule__LiteralValue__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_2__1"


    // $ANTLR start "rule__LiteralValue__Group_2__1__Impl"
    // InternalMickeyLang.g:9801:1: rule__LiteralValue__Group_2__1__Impl : ( ( rule__LiteralValue__LiteralAssignment_2_1 ) ) ;
    public final void rule__LiteralValue__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9805:1: ( ( ( rule__LiteralValue__LiteralAssignment_2_1 ) ) )
            // InternalMickeyLang.g:9806:1: ( ( rule__LiteralValue__LiteralAssignment_2_1 ) )
            {
            // InternalMickeyLang.g:9806:1: ( ( rule__LiteralValue__LiteralAssignment_2_1 ) )
            // InternalMickeyLang.g:9807:2: ( rule__LiteralValue__LiteralAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralAssignment_2_1()); 
            }
            // InternalMickeyLang.g:9808:2: ( rule__LiteralValue__LiteralAssignment_2_1 )
            // InternalMickeyLang.g:9808:3: rule__LiteralValue__LiteralAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__LiteralAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralAssignment_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_2__1__Impl"


    // $ANTLR start "rule__LiteralValue__Group_3__0"
    // InternalMickeyLang.g:9817:1: rule__LiteralValue__Group_3__0 : rule__LiteralValue__Group_3__0__Impl rule__LiteralValue__Group_3__1 ;
    public final void rule__LiteralValue__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9821:1: ( rule__LiteralValue__Group_3__0__Impl rule__LiteralValue__Group_3__1 )
            // InternalMickeyLang.g:9822:2: rule__LiteralValue__Group_3__0__Impl rule__LiteralValue__Group_3__1
            {
            pushFollow(FOLLOW_78);
            rule__LiteralValue__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_3__0"


    // $ANTLR start "rule__LiteralValue__Group_3__0__Impl"
    // InternalMickeyLang.g:9829:1: rule__LiteralValue__Group_3__0__Impl : ( () ) ;
    public final void rule__LiteralValue__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9833:1: ( ( () ) )
            // InternalMickeyLang.g:9834:1: ( () )
            {
            // InternalMickeyLang.g:9834:1: ( () )
            // InternalMickeyLang.g:9835:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getCurrentTimeLiteralAction_3_0()); 
            }
            // InternalMickeyLang.g:9836:2: ()
            // InternalMickeyLang.g:9836:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getCurrentTimeLiteralAction_3_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_3__0__Impl"


    // $ANTLR start "rule__LiteralValue__Group_3__1"
    // InternalMickeyLang.g:9844:1: rule__LiteralValue__Group_3__1 : rule__LiteralValue__Group_3__1__Impl ;
    public final void rule__LiteralValue__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9848:1: ( rule__LiteralValue__Group_3__1__Impl )
            // InternalMickeyLang.g:9849:2: rule__LiteralValue__Group_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_3__1"


    // $ANTLR start "rule__LiteralValue__Group_3__1__Impl"
    // InternalMickeyLang.g:9855:1: rule__LiteralValue__Group_3__1__Impl : ( ( rule__LiteralValue__LiteralAssignment_3_1 ) ) ;
    public final void rule__LiteralValue__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9859:1: ( ( ( rule__LiteralValue__LiteralAssignment_3_1 ) ) )
            // InternalMickeyLang.g:9860:1: ( ( rule__LiteralValue__LiteralAssignment_3_1 ) )
            {
            // InternalMickeyLang.g:9860:1: ( ( rule__LiteralValue__LiteralAssignment_3_1 ) )
            // InternalMickeyLang.g:9861:2: ( rule__LiteralValue__LiteralAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralAssignment_3_1()); 
            }
            // InternalMickeyLang.g:9862:2: ( rule__LiteralValue__LiteralAssignment_3_1 )
            // InternalMickeyLang.g:9862:3: rule__LiteralValue__LiteralAssignment_3_1
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__LiteralAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralAssignment_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_3__1__Impl"


    // $ANTLR start "rule__LiteralValue__Group_4__0"
    // InternalMickeyLang.g:9871:1: rule__LiteralValue__Group_4__0 : rule__LiteralValue__Group_4__0__Impl rule__LiteralValue__Group_4__1 ;
    public final void rule__LiteralValue__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9875:1: ( rule__LiteralValue__Group_4__0__Impl rule__LiteralValue__Group_4__1 )
            // InternalMickeyLang.g:9876:2: rule__LiteralValue__Group_4__0__Impl rule__LiteralValue__Group_4__1
            {
            pushFollow(FOLLOW_79);
            rule__LiteralValue__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_4__0"


    // $ANTLR start "rule__LiteralValue__Group_4__0__Impl"
    // InternalMickeyLang.g:9883:1: rule__LiteralValue__Group_4__0__Impl : ( () ) ;
    public final void rule__LiteralValue__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9887:1: ( ( () ) )
            // InternalMickeyLang.g:9888:1: ( () )
            {
            // InternalMickeyLang.g:9888:1: ( () )
            // InternalMickeyLang.g:9889:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getCurrentDateLiteralAction_4_0()); 
            }
            // InternalMickeyLang.g:9890:2: ()
            // InternalMickeyLang.g:9890:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getCurrentDateLiteralAction_4_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_4__0__Impl"


    // $ANTLR start "rule__LiteralValue__Group_4__1"
    // InternalMickeyLang.g:9898:1: rule__LiteralValue__Group_4__1 : rule__LiteralValue__Group_4__1__Impl ;
    public final void rule__LiteralValue__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9902:1: ( rule__LiteralValue__Group_4__1__Impl )
            // InternalMickeyLang.g:9903:2: rule__LiteralValue__Group_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_4__1"


    // $ANTLR start "rule__LiteralValue__Group_4__1__Impl"
    // InternalMickeyLang.g:9909:1: rule__LiteralValue__Group_4__1__Impl : ( ( rule__LiteralValue__LiteralAssignment_4_1 ) ) ;
    public final void rule__LiteralValue__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9913:1: ( ( ( rule__LiteralValue__LiteralAssignment_4_1 ) ) )
            // InternalMickeyLang.g:9914:1: ( ( rule__LiteralValue__LiteralAssignment_4_1 ) )
            {
            // InternalMickeyLang.g:9914:1: ( ( rule__LiteralValue__LiteralAssignment_4_1 ) )
            // InternalMickeyLang.g:9915:2: ( rule__LiteralValue__LiteralAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralAssignment_4_1()); 
            }
            // InternalMickeyLang.g:9916:2: ( rule__LiteralValue__LiteralAssignment_4_1 )
            // InternalMickeyLang.g:9916:3: rule__LiteralValue__LiteralAssignment_4_1
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__LiteralAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralAssignment_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_4__1__Impl"


    // $ANTLR start "rule__LiteralValue__Group_5__0"
    // InternalMickeyLang.g:9925:1: rule__LiteralValue__Group_5__0 : rule__LiteralValue__Group_5__0__Impl rule__LiteralValue__Group_5__1 ;
    public final void rule__LiteralValue__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9929:1: ( rule__LiteralValue__Group_5__0__Impl rule__LiteralValue__Group_5__1 )
            // InternalMickeyLang.g:9930:2: rule__LiteralValue__Group_5__0__Impl rule__LiteralValue__Group_5__1
            {
            pushFollow(FOLLOW_51);
            rule__LiteralValue__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_5__0"


    // $ANTLR start "rule__LiteralValue__Group_5__0__Impl"
    // InternalMickeyLang.g:9937:1: rule__LiteralValue__Group_5__0__Impl : ( () ) ;
    public final void rule__LiteralValue__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9941:1: ( ( () ) )
            // InternalMickeyLang.g:9942:1: ( () )
            {
            // InternalMickeyLang.g:9942:1: ( () )
            // InternalMickeyLang.g:9943:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getCurrentTimeStampLiteralAction_5_0()); 
            }
            // InternalMickeyLang.g:9944:2: ()
            // InternalMickeyLang.g:9944:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getCurrentTimeStampLiteralAction_5_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_5__0__Impl"


    // $ANTLR start "rule__LiteralValue__Group_5__1"
    // InternalMickeyLang.g:9952:1: rule__LiteralValue__Group_5__1 : rule__LiteralValue__Group_5__1__Impl ;
    public final void rule__LiteralValue__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9956:1: ( rule__LiteralValue__Group_5__1__Impl )
            // InternalMickeyLang.g:9957:2: rule__LiteralValue__Group_5__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_5__1"


    // $ANTLR start "rule__LiteralValue__Group_5__1__Impl"
    // InternalMickeyLang.g:9963:1: rule__LiteralValue__Group_5__1__Impl : ( ( rule__LiteralValue__LiteralAssignment_5_1 ) ) ;
    public final void rule__LiteralValue__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9967:1: ( ( ( rule__LiteralValue__LiteralAssignment_5_1 ) ) )
            // InternalMickeyLang.g:9968:1: ( ( rule__LiteralValue__LiteralAssignment_5_1 ) )
            {
            // InternalMickeyLang.g:9968:1: ( ( rule__LiteralValue__LiteralAssignment_5_1 ) )
            // InternalMickeyLang.g:9969:2: ( rule__LiteralValue__LiteralAssignment_5_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralAssignment_5_1()); 
            }
            // InternalMickeyLang.g:9970:2: ( rule__LiteralValue__LiteralAssignment_5_1 )
            // InternalMickeyLang.g:9970:3: rule__LiteralValue__LiteralAssignment_5_1
            {
            pushFollow(FOLLOW_2);
            rule__LiteralValue__LiteralAssignment_5_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralAssignment_5_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__Group_5__1__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__0"
    // InternalMickeyLang.g:9979:1: rule__CreateTableStatement__Group__0 : rule__CreateTableStatement__Group__0__Impl rule__CreateTableStatement__Group__1 ;
    public final void rule__CreateTableStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9983:1: ( rule__CreateTableStatement__Group__0__Impl rule__CreateTableStatement__Group__1 )
            // InternalMickeyLang.g:9984:2: rule__CreateTableStatement__Group__0__Impl rule__CreateTableStatement__Group__1
            {
            pushFollow(FOLLOW_80);
            rule__CreateTableStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__0"


    // $ANTLR start "rule__CreateTableStatement__Group__0__Impl"
    // InternalMickeyLang.g:9991:1: rule__CreateTableStatement__Group__0__Impl : ( () ) ;
    public final void rule__CreateTableStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:9995:1: ( ( () ) )
            // InternalMickeyLang.g:9996:1: ( () )
            {
            // InternalMickeyLang.g:9996:1: ( () )
            // InternalMickeyLang.g:9997:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getCreateTableStatementAction_0()); 
            }
            // InternalMickeyLang.g:9998:2: ()
            // InternalMickeyLang.g:9998:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getCreateTableStatementAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__0__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__1"
    // InternalMickeyLang.g:10006:1: rule__CreateTableStatement__Group__1 : rule__CreateTableStatement__Group__1__Impl rule__CreateTableStatement__Group__2 ;
    public final void rule__CreateTableStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10010:1: ( rule__CreateTableStatement__Group__1__Impl rule__CreateTableStatement__Group__2 )
            // InternalMickeyLang.g:10011:2: rule__CreateTableStatement__Group__1__Impl rule__CreateTableStatement__Group__2
            {
            pushFollow(FOLLOW_81);
            rule__CreateTableStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__1"


    // $ANTLR start "rule__CreateTableStatement__Group__1__Impl"
    // InternalMickeyLang.g:10018:1: rule__CreateTableStatement__Group__1__Impl : ( 'create' ) ;
    public final void rule__CreateTableStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10022:1: ( ( 'create' ) )
            // InternalMickeyLang.g:10023:1: ( 'create' )
            {
            // InternalMickeyLang.g:10023:1: ( 'create' )
            // InternalMickeyLang.g:10024:2: 'create'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getCreateKeyword_1()); 
            }
            match(input,93,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getCreateKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__1__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__2"
    // InternalMickeyLang.g:10033:1: rule__CreateTableStatement__Group__2 : rule__CreateTableStatement__Group__2__Impl rule__CreateTableStatement__Group__3 ;
    public final void rule__CreateTableStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10037:1: ( rule__CreateTableStatement__Group__2__Impl rule__CreateTableStatement__Group__3 )
            // InternalMickeyLang.g:10038:2: rule__CreateTableStatement__Group__2__Impl rule__CreateTableStatement__Group__3
            {
            pushFollow(FOLLOW_81);
            rule__CreateTableStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__2"


    // $ANTLR start "rule__CreateTableStatement__Group__2__Impl"
    // InternalMickeyLang.g:10045:1: rule__CreateTableStatement__Group__2__Impl : ( ( rule__CreateTableStatement__TemporaryAssignment_2 )? ) ;
    public final void rule__CreateTableStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10049:1: ( ( ( rule__CreateTableStatement__TemporaryAssignment_2 )? ) )
            // InternalMickeyLang.g:10050:1: ( ( rule__CreateTableStatement__TemporaryAssignment_2 )? )
            {
            // InternalMickeyLang.g:10050:1: ( ( rule__CreateTableStatement__TemporaryAssignment_2 )? )
            // InternalMickeyLang.g:10051:2: ( rule__CreateTableStatement__TemporaryAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getTemporaryAssignment_2()); 
            }
            // InternalMickeyLang.g:10052:2: ( rule__CreateTableStatement__TemporaryAssignment_2 )?
            int alt89=2;
            int LA89_0 = input.LA(1);

            if ( (LA89_0==135) ) {
                alt89=1;
            }
            switch (alt89) {
                case 1 :
                    // InternalMickeyLang.g:10052:3: rule__CreateTableStatement__TemporaryAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTableStatement__TemporaryAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getTemporaryAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__2__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__3"
    // InternalMickeyLang.g:10060:1: rule__CreateTableStatement__Group__3 : rule__CreateTableStatement__Group__3__Impl rule__CreateTableStatement__Group__4 ;
    public final void rule__CreateTableStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10064:1: ( rule__CreateTableStatement__Group__3__Impl rule__CreateTableStatement__Group__4 )
            // InternalMickeyLang.g:10065:2: rule__CreateTableStatement__Group__3__Impl rule__CreateTableStatement__Group__4
            {
            pushFollow(FOLLOW_3);
            rule__CreateTableStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__3"


    // $ANTLR start "rule__CreateTableStatement__Group__3__Impl"
    // InternalMickeyLang.g:10072:1: rule__CreateTableStatement__Group__3__Impl : ( 'table' ) ;
    public final void rule__CreateTableStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10076:1: ( ( 'table' ) )
            // InternalMickeyLang.g:10077:1: ( 'table' )
            {
            // InternalMickeyLang.g:10077:1: ( 'table' )
            // InternalMickeyLang.g:10078:2: 'table'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getTableKeyword_3()); 
            }
            match(input,94,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getTableKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__3__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__4"
    // InternalMickeyLang.g:10087:1: rule__CreateTableStatement__Group__4 : rule__CreateTableStatement__Group__4__Impl rule__CreateTableStatement__Group__5 ;
    public final void rule__CreateTableStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10091:1: ( rule__CreateTableStatement__Group__4__Impl rule__CreateTableStatement__Group__5 )
            // InternalMickeyLang.g:10092:2: rule__CreateTableStatement__Group__4__Impl rule__CreateTableStatement__Group__5
            {
            pushFollow(FOLLOW_6);
            rule__CreateTableStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__4"


    // $ANTLR start "rule__CreateTableStatement__Group__4__Impl"
    // InternalMickeyLang.g:10099:1: rule__CreateTableStatement__Group__4__Impl : ( ( rule__CreateTableStatement__NameAssignment_4 ) ) ;
    public final void rule__CreateTableStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10103:1: ( ( ( rule__CreateTableStatement__NameAssignment_4 ) ) )
            // InternalMickeyLang.g:10104:1: ( ( rule__CreateTableStatement__NameAssignment_4 ) )
            {
            // InternalMickeyLang.g:10104:1: ( ( rule__CreateTableStatement__NameAssignment_4 ) )
            // InternalMickeyLang.g:10105:2: ( rule__CreateTableStatement__NameAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getNameAssignment_4()); 
            }
            // InternalMickeyLang.g:10106:2: ( rule__CreateTableStatement__NameAssignment_4 )
            // InternalMickeyLang.g:10106:3: rule__CreateTableStatement__NameAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__NameAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getNameAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__4__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__5"
    // InternalMickeyLang.g:10114:1: rule__CreateTableStatement__Group__5 : rule__CreateTableStatement__Group__5__Impl rule__CreateTableStatement__Group__6 ;
    public final void rule__CreateTableStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10118:1: ( rule__CreateTableStatement__Group__5__Impl rule__CreateTableStatement__Group__6 )
            // InternalMickeyLang.g:10119:2: rule__CreateTableStatement__Group__5__Impl rule__CreateTableStatement__Group__6
            {
            pushFollow(FOLLOW_3);
            rule__CreateTableStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__5"


    // $ANTLR start "rule__CreateTableStatement__Group__5__Impl"
    // InternalMickeyLang.g:10126:1: rule__CreateTableStatement__Group__5__Impl : ( '(' ) ;
    public final void rule__CreateTableStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10130:1: ( ( '(' ) )
            // InternalMickeyLang.g:10131:1: ( '(' )
            {
            // InternalMickeyLang.g:10131:1: ( '(' )
            // InternalMickeyLang.g:10132:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getLeftParenthesisKeyword_5()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getLeftParenthesisKeyword_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__5__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__6"
    // InternalMickeyLang.g:10141:1: rule__CreateTableStatement__Group__6 : rule__CreateTableStatement__Group__6__Impl rule__CreateTableStatement__Group__7 ;
    public final void rule__CreateTableStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10145:1: ( rule__CreateTableStatement__Group__6__Impl rule__CreateTableStatement__Group__7 )
            // InternalMickeyLang.g:10146:2: rule__CreateTableStatement__Group__6__Impl rule__CreateTableStatement__Group__7
            {
            pushFollow(FOLLOW_82);
            rule__CreateTableStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__6"


    // $ANTLR start "rule__CreateTableStatement__Group__6__Impl"
    // InternalMickeyLang.g:10153:1: rule__CreateTableStatement__Group__6__Impl : ( ( rule__CreateTableStatement__ColumnDefsAssignment_6 ) ) ;
    public final void rule__CreateTableStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10157:1: ( ( ( rule__CreateTableStatement__ColumnDefsAssignment_6 ) ) )
            // InternalMickeyLang.g:10158:1: ( ( rule__CreateTableStatement__ColumnDefsAssignment_6 ) )
            {
            // InternalMickeyLang.g:10158:1: ( ( rule__CreateTableStatement__ColumnDefsAssignment_6 ) )
            // InternalMickeyLang.g:10159:2: ( rule__CreateTableStatement__ColumnDefsAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getColumnDefsAssignment_6()); 
            }
            // InternalMickeyLang.g:10160:2: ( rule__CreateTableStatement__ColumnDefsAssignment_6 )
            // InternalMickeyLang.g:10160:3: rule__CreateTableStatement__ColumnDefsAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__ColumnDefsAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getColumnDefsAssignment_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__6__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__7"
    // InternalMickeyLang.g:10168:1: rule__CreateTableStatement__Group__7 : rule__CreateTableStatement__Group__7__Impl rule__CreateTableStatement__Group__8 ;
    public final void rule__CreateTableStatement__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10172:1: ( rule__CreateTableStatement__Group__7__Impl rule__CreateTableStatement__Group__8 )
            // InternalMickeyLang.g:10173:2: rule__CreateTableStatement__Group__7__Impl rule__CreateTableStatement__Group__8
            {
            pushFollow(FOLLOW_82);
            rule__CreateTableStatement__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__8();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__7"


    // $ANTLR start "rule__CreateTableStatement__Group__7__Impl"
    // InternalMickeyLang.g:10180:1: rule__CreateTableStatement__Group__7__Impl : ( ( rule__CreateTableStatement__Group_7__0 )* ) ;
    public final void rule__CreateTableStatement__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10184:1: ( ( ( rule__CreateTableStatement__Group_7__0 )* ) )
            // InternalMickeyLang.g:10185:1: ( ( rule__CreateTableStatement__Group_7__0 )* )
            {
            // InternalMickeyLang.g:10185:1: ( ( rule__CreateTableStatement__Group_7__0 )* )
            // InternalMickeyLang.g:10186:2: ( rule__CreateTableStatement__Group_7__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getGroup_7()); 
            }
            // InternalMickeyLang.g:10187:2: ( rule__CreateTableStatement__Group_7__0 )*
            loop90:
            do {
                int alt90=2;
                int LA90_0 = input.LA(1);

                if ( (LA90_0==40) ) {
                    int LA90_1 = input.LA(2);

                    if ( (LA90_1==RULE_ID) ) {
                        alt90=1;
                    }


                }


                switch (alt90) {
            	case 1 :
            	    // InternalMickeyLang.g:10187:3: rule__CreateTableStatement__Group_7__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__CreateTableStatement__Group_7__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop90;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getGroup_7()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__7__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__8"
    // InternalMickeyLang.g:10195:1: rule__CreateTableStatement__Group__8 : rule__CreateTableStatement__Group__8__Impl rule__CreateTableStatement__Group__9 ;
    public final void rule__CreateTableStatement__Group__8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10199:1: ( rule__CreateTableStatement__Group__8__Impl rule__CreateTableStatement__Group__9 )
            // InternalMickeyLang.g:10200:2: rule__CreateTableStatement__Group__8__Impl rule__CreateTableStatement__Group__9
            {
            pushFollow(FOLLOW_82);
            rule__CreateTableStatement__Group__8__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__9();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__8"


    // $ANTLR start "rule__CreateTableStatement__Group__8__Impl"
    // InternalMickeyLang.g:10207:1: rule__CreateTableStatement__Group__8__Impl : ( ( rule__CreateTableStatement__Group_8__0 )* ) ;
    public final void rule__CreateTableStatement__Group__8__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10211:1: ( ( ( rule__CreateTableStatement__Group_8__0 )* ) )
            // InternalMickeyLang.g:10212:1: ( ( rule__CreateTableStatement__Group_8__0 )* )
            {
            // InternalMickeyLang.g:10212:1: ( ( rule__CreateTableStatement__Group_8__0 )* )
            // InternalMickeyLang.g:10213:2: ( rule__CreateTableStatement__Group_8__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getGroup_8()); 
            }
            // InternalMickeyLang.g:10214:2: ( rule__CreateTableStatement__Group_8__0 )*
            loop91:
            do {
                int alt91=2;
                int LA91_0 = input.LA(1);

                if ( (LA91_0==40) ) {
                    alt91=1;
                }


                switch (alt91) {
            	case 1 :
            	    // InternalMickeyLang.g:10214:3: rule__CreateTableStatement__Group_8__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__CreateTableStatement__Group_8__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop91;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getGroup_8()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__8__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group__9"
    // InternalMickeyLang.g:10222:1: rule__CreateTableStatement__Group__9 : rule__CreateTableStatement__Group__9__Impl ;
    public final void rule__CreateTableStatement__Group__9() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10226:1: ( rule__CreateTableStatement__Group__9__Impl )
            // InternalMickeyLang.g:10227:2: rule__CreateTableStatement__Group__9__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group__9__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__9"


    // $ANTLR start "rule__CreateTableStatement__Group__9__Impl"
    // InternalMickeyLang.g:10233:1: rule__CreateTableStatement__Group__9__Impl : ( ')' ) ;
    public final void rule__CreateTableStatement__Group__9__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10237:1: ( ( ')' ) )
            // InternalMickeyLang.g:10238:1: ( ')' )
            {
            // InternalMickeyLang.g:10238:1: ( ')' )
            // InternalMickeyLang.g:10239:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getRightParenthesisKeyword_9()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getRightParenthesisKeyword_9()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group__9__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group_7__0"
    // InternalMickeyLang.g:10249:1: rule__CreateTableStatement__Group_7__0 : rule__CreateTableStatement__Group_7__0__Impl rule__CreateTableStatement__Group_7__1 ;
    public final void rule__CreateTableStatement__Group_7__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10253:1: ( rule__CreateTableStatement__Group_7__0__Impl rule__CreateTableStatement__Group_7__1 )
            // InternalMickeyLang.g:10254:2: rule__CreateTableStatement__Group_7__0__Impl rule__CreateTableStatement__Group_7__1
            {
            pushFollow(FOLLOW_3);
            rule__CreateTableStatement__Group_7__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group_7__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_7__0"


    // $ANTLR start "rule__CreateTableStatement__Group_7__0__Impl"
    // InternalMickeyLang.g:10261:1: rule__CreateTableStatement__Group_7__0__Impl : ( ',' ) ;
    public final void rule__CreateTableStatement__Group_7__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10265:1: ( ( ',' ) )
            // InternalMickeyLang.g:10266:1: ( ',' )
            {
            // InternalMickeyLang.g:10266:1: ( ',' )
            // InternalMickeyLang.g:10267:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getCommaKeyword_7_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getCommaKeyword_7_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_7__0__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group_7__1"
    // InternalMickeyLang.g:10276:1: rule__CreateTableStatement__Group_7__1 : rule__CreateTableStatement__Group_7__1__Impl ;
    public final void rule__CreateTableStatement__Group_7__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10280:1: ( rule__CreateTableStatement__Group_7__1__Impl )
            // InternalMickeyLang.g:10281:2: rule__CreateTableStatement__Group_7__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group_7__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_7__1"


    // $ANTLR start "rule__CreateTableStatement__Group_7__1__Impl"
    // InternalMickeyLang.g:10287:1: rule__CreateTableStatement__Group_7__1__Impl : ( ( rule__CreateTableStatement__ColumnDefsAssignment_7_1 ) ) ;
    public final void rule__CreateTableStatement__Group_7__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10291:1: ( ( ( rule__CreateTableStatement__ColumnDefsAssignment_7_1 ) ) )
            // InternalMickeyLang.g:10292:1: ( ( rule__CreateTableStatement__ColumnDefsAssignment_7_1 ) )
            {
            // InternalMickeyLang.g:10292:1: ( ( rule__CreateTableStatement__ColumnDefsAssignment_7_1 ) )
            // InternalMickeyLang.g:10293:2: ( rule__CreateTableStatement__ColumnDefsAssignment_7_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getColumnDefsAssignment_7_1()); 
            }
            // InternalMickeyLang.g:10294:2: ( rule__CreateTableStatement__ColumnDefsAssignment_7_1 )
            // InternalMickeyLang.g:10294:3: rule__CreateTableStatement__ColumnDefsAssignment_7_1
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__ColumnDefsAssignment_7_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getColumnDefsAssignment_7_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_7__1__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group_8__0"
    // InternalMickeyLang.g:10303:1: rule__CreateTableStatement__Group_8__0 : rule__CreateTableStatement__Group_8__0__Impl rule__CreateTableStatement__Group_8__1 ;
    public final void rule__CreateTableStatement__Group_8__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10307:1: ( rule__CreateTableStatement__Group_8__0__Impl rule__CreateTableStatement__Group_8__1 )
            // InternalMickeyLang.g:10308:2: rule__CreateTableStatement__Group_8__0__Impl rule__CreateTableStatement__Group_8__1
            {
            pushFollow(FOLLOW_83);
            rule__CreateTableStatement__Group_8__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group_8__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_8__0"


    // $ANTLR start "rule__CreateTableStatement__Group_8__0__Impl"
    // InternalMickeyLang.g:10315:1: rule__CreateTableStatement__Group_8__0__Impl : ( ',' ) ;
    public final void rule__CreateTableStatement__Group_8__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10319:1: ( ( ',' ) )
            // InternalMickeyLang.g:10320:1: ( ',' )
            {
            // InternalMickeyLang.g:10320:1: ( ',' )
            // InternalMickeyLang.g:10321:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getCommaKeyword_8_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getCommaKeyword_8_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_8__0__Impl"


    // $ANTLR start "rule__CreateTableStatement__Group_8__1"
    // InternalMickeyLang.g:10330:1: rule__CreateTableStatement__Group_8__1 : rule__CreateTableStatement__Group_8__1__Impl ;
    public final void rule__CreateTableStatement__Group_8__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10334:1: ( rule__CreateTableStatement__Group_8__1__Impl )
            // InternalMickeyLang.g:10335:2: rule__CreateTableStatement__Group_8__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__Group_8__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_8__1"


    // $ANTLR start "rule__CreateTableStatement__Group_8__1__Impl"
    // InternalMickeyLang.g:10341:1: rule__CreateTableStatement__Group_8__1__Impl : ( ( rule__CreateTableStatement__ConstraintsAssignment_8_1 ) ) ;
    public final void rule__CreateTableStatement__Group_8__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10345:1: ( ( ( rule__CreateTableStatement__ConstraintsAssignment_8_1 ) ) )
            // InternalMickeyLang.g:10346:1: ( ( rule__CreateTableStatement__ConstraintsAssignment_8_1 ) )
            {
            // InternalMickeyLang.g:10346:1: ( ( rule__CreateTableStatement__ConstraintsAssignment_8_1 ) )
            // InternalMickeyLang.g:10347:2: ( rule__CreateTableStatement__ConstraintsAssignment_8_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getConstraintsAssignment_8_1()); 
            }
            // InternalMickeyLang.g:10348:2: ( rule__CreateTableStatement__ConstraintsAssignment_8_1 )
            // InternalMickeyLang.g:10348:3: rule__CreateTableStatement__ConstraintsAssignment_8_1
            {
            pushFollow(FOLLOW_2);
            rule__CreateTableStatement__ConstraintsAssignment_8_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getConstraintsAssignment_8_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__Group_8__1__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__0"
    // InternalMickeyLang.g:10357:1: rule__CreateViewStatement__Group__0 : rule__CreateViewStatement__Group__0__Impl rule__CreateViewStatement__Group__1 ;
    public final void rule__CreateViewStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10361:1: ( rule__CreateViewStatement__Group__0__Impl rule__CreateViewStatement__Group__1 )
            // InternalMickeyLang.g:10362:2: rule__CreateViewStatement__Group__0__Impl rule__CreateViewStatement__Group__1
            {
            pushFollow(FOLLOW_80);
            rule__CreateViewStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__0"


    // $ANTLR start "rule__CreateViewStatement__Group__0__Impl"
    // InternalMickeyLang.g:10369:1: rule__CreateViewStatement__Group__0__Impl : ( () ) ;
    public final void rule__CreateViewStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10373:1: ( ( () ) )
            // InternalMickeyLang.g:10374:1: ( () )
            {
            // InternalMickeyLang.g:10374:1: ( () )
            // InternalMickeyLang.g:10375:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getCreateViewStatementAction_0()); 
            }
            // InternalMickeyLang.g:10376:2: ()
            // InternalMickeyLang.g:10376:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getCreateViewStatementAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__0__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__1"
    // InternalMickeyLang.g:10384:1: rule__CreateViewStatement__Group__1 : rule__CreateViewStatement__Group__1__Impl rule__CreateViewStatement__Group__2 ;
    public final void rule__CreateViewStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10388:1: ( rule__CreateViewStatement__Group__1__Impl rule__CreateViewStatement__Group__2 )
            // InternalMickeyLang.g:10389:2: rule__CreateViewStatement__Group__1__Impl rule__CreateViewStatement__Group__2
            {
            pushFollow(FOLLOW_84);
            rule__CreateViewStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__1"


    // $ANTLR start "rule__CreateViewStatement__Group__1__Impl"
    // InternalMickeyLang.g:10396:1: rule__CreateViewStatement__Group__1__Impl : ( 'create' ) ;
    public final void rule__CreateViewStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10400:1: ( ( 'create' ) )
            // InternalMickeyLang.g:10401:1: ( 'create' )
            {
            // InternalMickeyLang.g:10401:1: ( 'create' )
            // InternalMickeyLang.g:10402:2: 'create'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getCreateKeyword_1()); 
            }
            match(input,93,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getCreateKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__1__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__2"
    // InternalMickeyLang.g:10411:1: rule__CreateViewStatement__Group__2 : rule__CreateViewStatement__Group__2__Impl rule__CreateViewStatement__Group__3 ;
    public final void rule__CreateViewStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10415:1: ( rule__CreateViewStatement__Group__2__Impl rule__CreateViewStatement__Group__3 )
            // InternalMickeyLang.g:10416:2: rule__CreateViewStatement__Group__2__Impl rule__CreateViewStatement__Group__3
            {
            pushFollow(FOLLOW_84);
            rule__CreateViewStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__2"


    // $ANTLR start "rule__CreateViewStatement__Group__2__Impl"
    // InternalMickeyLang.g:10423:1: rule__CreateViewStatement__Group__2__Impl : ( ( rule__CreateViewStatement__TemporaryAssignment_2 )? ) ;
    public final void rule__CreateViewStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10427:1: ( ( ( rule__CreateViewStatement__TemporaryAssignment_2 )? ) )
            // InternalMickeyLang.g:10428:1: ( ( rule__CreateViewStatement__TemporaryAssignment_2 )? )
            {
            // InternalMickeyLang.g:10428:1: ( ( rule__CreateViewStatement__TemporaryAssignment_2 )? )
            // InternalMickeyLang.g:10429:2: ( rule__CreateViewStatement__TemporaryAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getTemporaryAssignment_2()); 
            }
            // InternalMickeyLang.g:10430:2: ( rule__CreateViewStatement__TemporaryAssignment_2 )?
            int alt92=2;
            int LA92_0 = input.LA(1);

            if ( (LA92_0==135) ) {
                alt92=1;
            }
            switch (alt92) {
                case 1 :
                    // InternalMickeyLang.g:10430:3: rule__CreateViewStatement__TemporaryAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateViewStatement__TemporaryAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getTemporaryAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__2__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__3"
    // InternalMickeyLang.g:10438:1: rule__CreateViewStatement__Group__3 : rule__CreateViewStatement__Group__3__Impl rule__CreateViewStatement__Group__4 ;
    public final void rule__CreateViewStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10442:1: ( rule__CreateViewStatement__Group__3__Impl rule__CreateViewStatement__Group__4 )
            // InternalMickeyLang.g:10443:2: rule__CreateViewStatement__Group__3__Impl rule__CreateViewStatement__Group__4
            {
            pushFollow(FOLLOW_3);
            rule__CreateViewStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__3"


    // $ANTLR start "rule__CreateViewStatement__Group__3__Impl"
    // InternalMickeyLang.g:10450:1: rule__CreateViewStatement__Group__3__Impl : ( 'view' ) ;
    public final void rule__CreateViewStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10454:1: ( ( 'view' ) )
            // InternalMickeyLang.g:10455:1: ( 'view' )
            {
            // InternalMickeyLang.g:10455:1: ( 'view' )
            // InternalMickeyLang.g:10456:2: 'view'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getViewKeyword_3()); 
            }
            match(input,95,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getViewKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__3__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__4"
    // InternalMickeyLang.g:10465:1: rule__CreateViewStatement__Group__4 : rule__CreateViewStatement__Group__4__Impl rule__CreateViewStatement__Group__5 ;
    public final void rule__CreateViewStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10469:1: ( rule__CreateViewStatement__Group__4__Impl rule__CreateViewStatement__Group__5 )
            // InternalMickeyLang.g:10470:2: rule__CreateViewStatement__Group__4__Impl rule__CreateViewStatement__Group__5
            {
            pushFollow(FOLLOW_61);
            rule__CreateViewStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__4"


    // $ANTLR start "rule__CreateViewStatement__Group__4__Impl"
    // InternalMickeyLang.g:10477:1: rule__CreateViewStatement__Group__4__Impl : ( ( rule__CreateViewStatement__NameAssignment_4 ) ) ;
    public final void rule__CreateViewStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10481:1: ( ( ( rule__CreateViewStatement__NameAssignment_4 ) ) )
            // InternalMickeyLang.g:10482:1: ( ( rule__CreateViewStatement__NameAssignment_4 ) )
            {
            // InternalMickeyLang.g:10482:1: ( ( rule__CreateViewStatement__NameAssignment_4 ) )
            // InternalMickeyLang.g:10483:2: ( rule__CreateViewStatement__NameAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getNameAssignment_4()); 
            }
            // InternalMickeyLang.g:10484:2: ( rule__CreateViewStatement__NameAssignment_4 )
            // InternalMickeyLang.g:10484:3: rule__CreateViewStatement__NameAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__NameAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getNameAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__4__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__5"
    // InternalMickeyLang.g:10492:1: rule__CreateViewStatement__Group__5 : rule__CreateViewStatement__Group__5__Impl rule__CreateViewStatement__Group__6 ;
    public final void rule__CreateViewStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10496:1: ( rule__CreateViewStatement__Group__5__Impl rule__CreateViewStatement__Group__6 )
            // InternalMickeyLang.g:10497:2: rule__CreateViewStatement__Group__5__Impl rule__CreateViewStatement__Group__6
            {
            pushFollow(FOLLOW_54);
            rule__CreateViewStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__5"


    // $ANTLR start "rule__CreateViewStatement__Group__5__Impl"
    // InternalMickeyLang.g:10504:1: rule__CreateViewStatement__Group__5__Impl : ( 'as' ) ;
    public final void rule__CreateViewStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10508:1: ( ( 'as' ) )
            // InternalMickeyLang.g:10509:1: ( 'as' )
            {
            // InternalMickeyLang.g:10509:1: ( 'as' )
            // InternalMickeyLang.g:10510:2: 'as'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getAsKeyword_5()); 
            }
            match(input,82,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getAsKeyword_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__5__Impl"


    // $ANTLR start "rule__CreateViewStatement__Group__6"
    // InternalMickeyLang.g:10519:1: rule__CreateViewStatement__Group__6 : rule__CreateViewStatement__Group__6__Impl ;
    public final void rule__CreateViewStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10523:1: ( rule__CreateViewStatement__Group__6__Impl )
            // InternalMickeyLang.g:10524:2: rule__CreateViewStatement__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__6"


    // $ANTLR start "rule__CreateViewStatement__Group__6__Impl"
    // InternalMickeyLang.g:10530:1: rule__CreateViewStatement__Group__6__Impl : ( ( rule__CreateViewStatement__SelectStatementAssignment_6 ) ) ;
    public final void rule__CreateViewStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10534:1: ( ( ( rule__CreateViewStatement__SelectStatementAssignment_6 ) ) )
            // InternalMickeyLang.g:10535:1: ( ( rule__CreateViewStatement__SelectStatementAssignment_6 ) )
            {
            // InternalMickeyLang.g:10535:1: ( ( rule__CreateViewStatement__SelectStatementAssignment_6 ) )
            // InternalMickeyLang.g:10536:2: ( rule__CreateViewStatement__SelectStatementAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getSelectStatementAssignment_6()); 
            }
            // InternalMickeyLang.g:10537:2: ( rule__CreateViewStatement__SelectStatementAssignment_6 )
            // InternalMickeyLang.g:10537:3: rule__CreateViewStatement__SelectStatementAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__CreateViewStatement__SelectStatementAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getSelectStatementAssignment_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__Group__6__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__0"
    // InternalMickeyLang.g:10546:1: rule__CreateTriggerStatement__Group__0 : rule__CreateTriggerStatement__Group__0__Impl rule__CreateTriggerStatement__Group__1 ;
    public final void rule__CreateTriggerStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10550:1: ( rule__CreateTriggerStatement__Group__0__Impl rule__CreateTriggerStatement__Group__1 )
            // InternalMickeyLang.g:10551:2: rule__CreateTriggerStatement__Group__0__Impl rule__CreateTriggerStatement__Group__1
            {
            pushFollow(FOLLOW_85);
            rule__CreateTriggerStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group__0__Impl"
    // InternalMickeyLang.g:10558:1: rule__CreateTriggerStatement__Group__0__Impl : ( 'create' ) ;
    public final void rule__CreateTriggerStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10562:1: ( ( 'create' ) )
            // InternalMickeyLang.g:10563:1: ( 'create' )
            {
            // InternalMickeyLang.g:10563:1: ( 'create' )
            // InternalMickeyLang.g:10564:2: 'create'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getCreateKeyword_0()); 
            }
            match(input,93,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getCreateKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__1"
    // InternalMickeyLang.g:10573:1: rule__CreateTriggerStatement__Group__1 : rule__CreateTriggerStatement__Group__1__Impl rule__CreateTriggerStatement__Group__2 ;
    public final void rule__CreateTriggerStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10577:1: ( rule__CreateTriggerStatement__Group__1__Impl rule__CreateTriggerStatement__Group__2 )
            // InternalMickeyLang.g:10578:2: rule__CreateTriggerStatement__Group__1__Impl rule__CreateTriggerStatement__Group__2
            {
            pushFollow(FOLLOW_85);
            rule__CreateTriggerStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group__1__Impl"
    // InternalMickeyLang.g:10585:1: rule__CreateTriggerStatement__Group__1__Impl : ( ( rule__CreateTriggerStatement__TemporaryAssignment_1 )? ) ;
    public final void rule__CreateTriggerStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10589:1: ( ( ( rule__CreateTriggerStatement__TemporaryAssignment_1 )? ) )
            // InternalMickeyLang.g:10590:1: ( ( rule__CreateTriggerStatement__TemporaryAssignment_1 )? )
            {
            // InternalMickeyLang.g:10590:1: ( ( rule__CreateTriggerStatement__TemporaryAssignment_1 )? )
            // InternalMickeyLang.g:10591:2: ( rule__CreateTriggerStatement__TemporaryAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTemporaryAssignment_1()); 
            }
            // InternalMickeyLang.g:10592:2: ( rule__CreateTriggerStatement__TemporaryAssignment_1 )?
            int alt93=2;
            int LA93_0 = input.LA(1);

            if ( (LA93_0==135) ) {
                alt93=1;
            }
            switch (alt93) {
                case 1 :
                    // InternalMickeyLang.g:10592:3: rule__CreateTriggerStatement__TemporaryAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__TemporaryAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTemporaryAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__1__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__2"
    // InternalMickeyLang.g:10600:1: rule__CreateTriggerStatement__Group__2 : rule__CreateTriggerStatement__Group__2__Impl rule__CreateTriggerStatement__Group__3 ;
    public final void rule__CreateTriggerStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10604:1: ( rule__CreateTriggerStatement__Group__2__Impl rule__CreateTriggerStatement__Group__3 )
            // InternalMickeyLang.g:10605:2: rule__CreateTriggerStatement__Group__2__Impl rule__CreateTriggerStatement__Group__3
            {
            pushFollow(FOLLOW_3);
            rule__CreateTriggerStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__2"


    // $ANTLR start "rule__CreateTriggerStatement__Group__2__Impl"
    // InternalMickeyLang.g:10612:1: rule__CreateTriggerStatement__Group__2__Impl : ( 'trigger' ) ;
    public final void rule__CreateTriggerStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10616:1: ( ( 'trigger' ) )
            // InternalMickeyLang.g:10617:1: ( 'trigger' )
            {
            // InternalMickeyLang.g:10617:1: ( 'trigger' )
            // InternalMickeyLang.g:10618:2: 'trigger'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTriggerKeyword_2()); 
            }
            match(input,96,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTriggerKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__2__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__3"
    // InternalMickeyLang.g:10627:1: rule__CreateTriggerStatement__Group__3 : rule__CreateTriggerStatement__Group__3__Impl rule__CreateTriggerStatement__Group__4 ;
    public final void rule__CreateTriggerStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10631:1: ( rule__CreateTriggerStatement__Group__3__Impl rule__CreateTriggerStatement__Group__4 )
            // InternalMickeyLang.g:10632:2: rule__CreateTriggerStatement__Group__3__Impl rule__CreateTriggerStatement__Group__4
            {
            pushFollow(FOLLOW_86);
            rule__CreateTriggerStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__3"


    // $ANTLR start "rule__CreateTriggerStatement__Group__3__Impl"
    // InternalMickeyLang.g:10639:1: rule__CreateTriggerStatement__Group__3__Impl : ( ( rule__CreateTriggerStatement__NameAssignment_3 ) ) ;
    public final void rule__CreateTriggerStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10643:1: ( ( ( rule__CreateTriggerStatement__NameAssignment_3 ) ) )
            // InternalMickeyLang.g:10644:1: ( ( rule__CreateTriggerStatement__NameAssignment_3 ) )
            {
            // InternalMickeyLang.g:10644:1: ( ( rule__CreateTriggerStatement__NameAssignment_3 ) )
            // InternalMickeyLang.g:10645:2: ( rule__CreateTriggerStatement__NameAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getNameAssignment_3()); 
            }
            // InternalMickeyLang.g:10646:2: ( rule__CreateTriggerStatement__NameAssignment_3 )
            // InternalMickeyLang.g:10646:3: rule__CreateTriggerStatement__NameAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__NameAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getNameAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__3__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__4"
    // InternalMickeyLang.g:10654:1: rule__CreateTriggerStatement__Group__4 : rule__CreateTriggerStatement__Group__4__Impl rule__CreateTriggerStatement__Group__5 ;
    public final void rule__CreateTriggerStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10658:1: ( rule__CreateTriggerStatement__Group__4__Impl rule__CreateTriggerStatement__Group__5 )
            // InternalMickeyLang.g:10659:2: rule__CreateTriggerStatement__Group__4__Impl rule__CreateTriggerStatement__Group__5
            {
            pushFollow(FOLLOW_86);
            rule__CreateTriggerStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__4"


    // $ANTLR start "rule__CreateTriggerStatement__Group__4__Impl"
    // InternalMickeyLang.g:10666:1: rule__CreateTriggerStatement__Group__4__Impl : ( ( rule__CreateTriggerStatement__WhenAssignment_4 )? ) ;
    public final void rule__CreateTriggerStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10670:1: ( ( ( rule__CreateTriggerStatement__WhenAssignment_4 )? ) )
            // InternalMickeyLang.g:10671:1: ( ( rule__CreateTriggerStatement__WhenAssignment_4 )? )
            {
            // InternalMickeyLang.g:10671:1: ( ( rule__CreateTriggerStatement__WhenAssignment_4 )? )
            // InternalMickeyLang.g:10672:2: ( rule__CreateTriggerStatement__WhenAssignment_4 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getWhenAssignment_4()); 
            }
            // InternalMickeyLang.g:10673:2: ( rule__CreateTriggerStatement__WhenAssignment_4 )?
            int alt94=2;
            int LA94_0 = input.LA(1);

            if ( ((LA94_0>=41 && LA94_0<=43)) ) {
                alt94=1;
            }
            switch (alt94) {
                case 1 :
                    // InternalMickeyLang.g:10673:3: rule__CreateTriggerStatement__WhenAssignment_4
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__WhenAssignment_4();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getWhenAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__4__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__5"
    // InternalMickeyLang.g:10681:1: rule__CreateTriggerStatement__Group__5 : rule__CreateTriggerStatement__Group__5__Impl rule__CreateTriggerStatement__Group__6 ;
    public final void rule__CreateTriggerStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10685:1: ( rule__CreateTriggerStatement__Group__5__Impl rule__CreateTriggerStatement__Group__6 )
            // InternalMickeyLang.g:10686:2: rule__CreateTriggerStatement__Group__5__Impl rule__CreateTriggerStatement__Group__6
            {
            pushFollow(FOLLOW_16);
            rule__CreateTriggerStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__5"


    // $ANTLR start "rule__CreateTriggerStatement__Group__5__Impl"
    // InternalMickeyLang.g:10693:1: rule__CreateTriggerStatement__Group__5__Impl : ( ( rule__CreateTriggerStatement__Alternatives_5 ) ) ;
    public final void rule__CreateTriggerStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10697:1: ( ( ( rule__CreateTriggerStatement__Alternatives_5 ) ) )
            // InternalMickeyLang.g:10698:1: ( ( rule__CreateTriggerStatement__Alternatives_5 ) )
            {
            // InternalMickeyLang.g:10698:1: ( ( rule__CreateTriggerStatement__Alternatives_5 ) )
            // InternalMickeyLang.g:10699:2: ( rule__CreateTriggerStatement__Alternatives_5 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getAlternatives_5()); 
            }
            // InternalMickeyLang.g:10700:2: ( rule__CreateTriggerStatement__Alternatives_5 )
            // InternalMickeyLang.g:10700:3: rule__CreateTriggerStatement__Alternatives_5
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Alternatives_5();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getAlternatives_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__5__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__6"
    // InternalMickeyLang.g:10708:1: rule__CreateTriggerStatement__Group__6 : rule__CreateTriggerStatement__Group__6__Impl rule__CreateTriggerStatement__Group__7 ;
    public final void rule__CreateTriggerStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10712:1: ( rule__CreateTriggerStatement__Group__6__Impl rule__CreateTriggerStatement__Group__7 )
            // InternalMickeyLang.g:10713:2: rule__CreateTriggerStatement__Group__6__Impl rule__CreateTriggerStatement__Group__7
            {
            pushFollow(FOLLOW_3);
            rule__CreateTriggerStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__6"


    // $ANTLR start "rule__CreateTriggerStatement__Group__6__Impl"
    // InternalMickeyLang.g:10720:1: rule__CreateTriggerStatement__Group__6__Impl : ( 'on' ) ;
    public final void rule__CreateTriggerStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10724:1: ( ( 'on' ) )
            // InternalMickeyLang.g:10725:1: ( 'on' )
            {
            // InternalMickeyLang.g:10725:1: ( 'on' )
            // InternalMickeyLang.g:10726:2: 'on'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getOnKeyword_6()); 
            }
            match(input,69,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getOnKeyword_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__6__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__7"
    // InternalMickeyLang.g:10735:1: rule__CreateTriggerStatement__Group__7 : rule__CreateTriggerStatement__Group__7__Impl rule__CreateTriggerStatement__Group__8 ;
    public final void rule__CreateTriggerStatement__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10739:1: ( rule__CreateTriggerStatement__Group__7__Impl rule__CreateTriggerStatement__Group__8 )
            // InternalMickeyLang.g:10740:2: rule__CreateTriggerStatement__Group__7__Impl rule__CreateTriggerStatement__Group__8
            {
            pushFollow(FOLLOW_87);
            rule__CreateTriggerStatement__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__8();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__7"


    // $ANTLR start "rule__CreateTriggerStatement__Group__7__Impl"
    // InternalMickeyLang.g:10747:1: rule__CreateTriggerStatement__Group__7__Impl : ( ( rule__CreateTriggerStatement__TableAssignment_7 ) ) ;
    public final void rule__CreateTriggerStatement__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10751:1: ( ( ( rule__CreateTriggerStatement__TableAssignment_7 ) ) )
            // InternalMickeyLang.g:10752:1: ( ( rule__CreateTriggerStatement__TableAssignment_7 ) )
            {
            // InternalMickeyLang.g:10752:1: ( ( rule__CreateTriggerStatement__TableAssignment_7 ) )
            // InternalMickeyLang.g:10753:2: ( rule__CreateTriggerStatement__TableAssignment_7 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTableAssignment_7()); 
            }
            // InternalMickeyLang.g:10754:2: ( rule__CreateTriggerStatement__TableAssignment_7 )
            // InternalMickeyLang.g:10754:3: rule__CreateTriggerStatement__TableAssignment_7
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__TableAssignment_7();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTableAssignment_7()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__7__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__8"
    // InternalMickeyLang.g:10762:1: rule__CreateTriggerStatement__Group__8 : rule__CreateTriggerStatement__Group__8__Impl rule__CreateTriggerStatement__Group__9 ;
    public final void rule__CreateTriggerStatement__Group__8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10766:1: ( rule__CreateTriggerStatement__Group__8__Impl rule__CreateTriggerStatement__Group__9 )
            // InternalMickeyLang.g:10767:2: rule__CreateTriggerStatement__Group__8__Impl rule__CreateTriggerStatement__Group__9
            {
            pushFollow(FOLLOW_87);
            rule__CreateTriggerStatement__Group__8__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__9();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__8"


    // $ANTLR start "rule__CreateTriggerStatement__Group__8__Impl"
    // InternalMickeyLang.g:10774:1: rule__CreateTriggerStatement__Group__8__Impl : ( ( rule__CreateTriggerStatement__ForEachRowAssignment_8 )? ) ;
    public final void rule__CreateTriggerStatement__Group__8__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10778:1: ( ( ( rule__CreateTriggerStatement__ForEachRowAssignment_8 )? ) )
            // InternalMickeyLang.g:10779:1: ( ( rule__CreateTriggerStatement__ForEachRowAssignment_8 )? )
            {
            // InternalMickeyLang.g:10779:1: ( ( rule__CreateTriggerStatement__ForEachRowAssignment_8 )? )
            // InternalMickeyLang.g:10780:2: ( rule__CreateTriggerStatement__ForEachRowAssignment_8 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getForEachRowAssignment_8()); 
            }
            // InternalMickeyLang.g:10781:2: ( rule__CreateTriggerStatement__ForEachRowAssignment_8 )?
            int alt95=2;
            int LA95_0 = input.LA(1);

            if ( (LA95_0==136) ) {
                alt95=1;
            }
            switch (alt95) {
                case 1 :
                    // InternalMickeyLang.g:10781:3: rule__CreateTriggerStatement__ForEachRowAssignment_8
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__ForEachRowAssignment_8();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getForEachRowAssignment_8()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__8__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__9"
    // InternalMickeyLang.g:10789:1: rule__CreateTriggerStatement__Group__9 : rule__CreateTriggerStatement__Group__9__Impl rule__CreateTriggerStatement__Group__10 ;
    public final void rule__CreateTriggerStatement__Group__9() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10793:1: ( rule__CreateTriggerStatement__Group__9__Impl rule__CreateTriggerStatement__Group__10 )
            // InternalMickeyLang.g:10794:2: rule__CreateTriggerStatement__Group__9__Impl rule__CreateTriggerStatement__Group__10
            {
            pushFollow(FOLLOW_87);
            rule__CreateTriggerStatement__Group__9__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__10();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__9"


    // $ANTLR start "rule__CreateTriggerStatement__Group__9__Impl"
    // InternalMickeyLang.g:10801:1: rule__CreateTriggerStatement__Group__9__Impl : ( ( rule__CreateTriggerStatement__Group_9__0 )? ) ;
    public final void rule__CreateTriggerStatement__Group__9__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10805:1: ( ( ( rule__CreateTriggerStatement__Group_9__0 )? ) )
            // InternalMickeyLang.g:10806:1: ( ( rule__CreateTriggerStatement__Group_9__0 )? )
            {
            // InternalMickeyLang.g:10806:1: ( ( rule__CreateTriggerStatement__Group_9__0 )? )
            // InternalMickeyLang.g:10807:2: ( rule__CreateTriggerStatement__Group_9__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getGroup_9()); 
            }
            // InternalMickeyLang.g:10808:2: ( rule__CreateTriggerStatement__Group_9__0 )?
            int alt96=2;
            int LA96_0 = input.LA(1);

            if ( (LA96_0==84) ) {
                alt96=1;
            }
            switch (alt96) {
                case 1 :
                    // InternalMickeyLang.g:10808:3: rule__CreateTriggerStatement__Group_9__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__Group_9__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getGroup_9()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__9__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__10"
    // InternalMickeyLang.g:10816:1: rule__CreateTriggerStatement__Group__10 : rule__CreateTriggerStatement__Group__10__Impl rule__CreateTriggerStatement__Group__11 ;
    public final void rule__CreateTriggerStatement__Group__10() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10820:1: ( rule__CreateTriggerStatement__Group__10__Impl rule__CreateTriggerStatement__Group__11 )
            // InternalMickeyLang.g:10821:2: rule__CreateTriggerStatement__Group__10__Impl rule__CreateTriggerStatement__Group__11
            {
            pushFollow(FOLLOW_88);
            rule__CreateTriggerStatement__Group__10__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__11();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__10"


    // $ANTLR start "rule__CreateTriggerStatement__Group__10__Impl"
    // InternalMickeyLang.g:10828:1: rule__CreateTriggerStatement__Group__10__Impl : ( 'begin' ) ;
    public final void rule__CreateTriggerStatement__Group__10__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10832:1: ( ( 'begin' ) )
            // InternalMickeyLang.g:10833:1: ( 'begin' )
            {
            // InternalMickeyLang.g:10833:1: ( 'begin' )
            // InternalMickeyLang.g:10834:2: 'begin'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getBeginKeyword_10()); 
            }
            match(input,97,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getBeginKeyword_10()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__10__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__11"
    // InternalMickeyLang.g:10843:1: rule__CreateTriggerStatement__Group__11 : rule__CreateTriggerStatement__Group__11__Impl rule__CreateTriggerStatement__Group__12 ;
    public final void rule__CreateTriggerStatement__Group__11() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10847:1: ( rule__CreateTriggerStatement__Group__11__Impl rule__CreateTriggerStatement__Group__12 )
            // InternalMickeyLang.g:10848:2: rule__CreateTriggerStatement__Group__11__Impl rule__CreateTriggerStatement__Group__12
            {
            pushFollow(FOLLOW_88);
            rule__CreateTriggerStatement__Group__11__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__12();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__11"


    // $ANTLR start "rule__CreateTriggerStatement__Group__11__Impl"
    // InternalMickeyLang.g:10855:1: rule__CreateTriggerStatement__Group__11__Impl : ( ( rule__CreateTriggerStatement__Group_11__0 )? ) ;
    public final void rule__CreateTriggerStatement__Group__11__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10859:1: ( ( ( rule__CreateTriggerStatement__Group_11__0 )? ) )
            // InternalMickeyLang.g:10860:1: ( ( rule__CreateTriggerStatement__Group_11__0 )? )
            {
            // InternalMickeyLang.g:10860:1: ( ( rule__CreateTriggerStatement__Group_11__0 )? )
            // InternalMickeyLang.g:10861:2: ( rule__CreateTriggerStatement__Group_11__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getGroup_11()); 
            }
            // InternalMickeyLang.g:10862:2: ( rule__CreateTriggerStatement__Group_11__0 )?
            int alt97=2;
            int LA97_0 = input.LA(1);

            if ( (LA97_0==44||LA97_0==88||LA97_0==111||LA97_0==113||LA97_0==116) ) {
                alt97=1;
            }
            switch (alt97) {
                case 1 :
                    // InternalMickeyLang.g:10862:3: rule__CreateTriggerStatement__Group_11__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__Group_11__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getGroup_11()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__11__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group__12"
    // InternalMickeyLang.g:10870:1: rule__CreateTriggerStatement__Group__12 : rule__CreateTriggerStatement__Group__12__Impl ;
    public final void rule__CreateTriggerStatement__Group__12() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10874:1: ( rule__CreateTriggerStatement__Group__12__Impl )
            // InternalMickeyLang.g:10875:2: rule__CreateTriggerStatement__Group__12__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group__12__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__12"


    // $ANTLR start "rule__CreateTriggerStatement__Group__12__Impl"
    // InternalMickeyLang.g:10881:1: rule__CreateTriggerStatement__Group__12__Impl : ( 'end' ) ;
    public final void rule__CreateTriggerStatement__Group__12__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10885:1: ( ( 'end' ) )
            // InternalMickeyLang.g:10886:1: ( 'end' )
            {
            // InternalMickeyLang.g:10886:1: ( 'end' )
            // InternalMickeyLang.g:10887:2: 'end'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEndKeyword_12()); 
            }
            match(input,79,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEndKeyword_12()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group__12__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2__0"
    // InternalMickeyLang.g:10897:1: rule__CreateTriggerStatement__Group_5_2__0 : rule__CreateTriggerStatement__Group_5_2__0__Impl rule__CreateTriggerStatement__Group_5_2__1 ;
    public final void rule__CreateTriggerStatement__Group_5_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10901:1: ( rule__CreateTriggerStatement__Group_5_2__0__Impl rule__CreateTriggerStatement__Group_5_2__1 )
            // InternalMickeyLang.g:10902:2: rule__CreateTriggerStatement__Group_5_2__0__Impl rule__CreateTriggerStatement__Group_5_2__1
            {
            pushFollow(FOLLOW_89);
            rule__CreateTriggerStatement__Group_5_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2__0__Impl"
    // InternalMickeyLang.g:10909:1: rule__CreateTriggerStatement__Group_5_2__0__Impl : ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 ) ) ;
    public final void rule__CreateTriggerStatement__Group_5_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10913:1: ( ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 ) ) )
            // InternalMickeyLang.g:10914:1: ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 ) )
            {
            // InternalMickeyLang.g:10914:1: ( ( rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 ) )
            // InternalMickeyLang.g:10915:2: ( rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeAssignment_5_2_0()); 
            }
            // InternalMickeyLang.g:10916:2: ( rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 )
            // InternalMickeyLang.g:10916:3: rule__CreateTriggerStatement__EventTypeAssignment_5_2_0
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__EventTypeAssignment_5_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeAssignment_5_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2__1"
    // InternalMickeyLang.g:10924:1: rule__CreateTriggerStatement__Group_5_2__1 : rule__CreateTriggerStatement__Group_5_2__1__Impl ;
    public final void rule__CreateTriggerStatement__Group_5_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10928:1: ( rule__CreateTriggerStatement__Group_5_2__1__Impl )
            // InternalMickeyLang.g:10929:2: rule__CreateTriggerStatement__Group_5_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2__1__Impl"
    // InternalMickeyLang.g:10935:1: rule__CreateTriggerStatement__Group_5_2__1__Impl : ( ( rule__CreateTriggerStatement__Group_5_2_1__0 )? ) ;
    public final void rule__CreateTriggerStatement__Group_5_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10939:1: ( ( ( rule__CreateTriggerStatement__Group_5_2_1__0 )? ) )
            // InternalMickeyLang.g:10940:1: ( ( rule__CreateTriggerStatement__Group_5_2_1__0 )? )
            {
            // InternalMickeyLang.g:10940:1: ( ( rule__CreateTriggerStatement__Group_5_2_1__0 )? )
            // InternalMickeyLang.g:10941:2: ( rule__CreateTriggerStatement__Group_5_2_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getGroup_5_2_1()); 
            }
            // InternalMickeyLang.g:10942:2: ( rule__CreateTriggerStatement__Group_5_2_1__0 )?
            int alt98=2;
            int LA98_0 = input.LA(1);

            if ( (LA98_0==98) ) {
                alt98=1;
            }
            switch (alt98) {
                case 1 :
                    // InternalMickeyLang.g:10942:3: rule__CreateTriggerStatement__Group_5_2_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateTriggerStatement__Group_5_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getGroup_5_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2__1__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1__0"
    // InternalMickeyLang.g:10951:1: rule__CreateTriggerStatement__Group_5_2_1__0 : rule__CreateTriggerStatement__Group_5_2_1__0__Impl rule__CreateTriggerStatement__Group_5_2_1__1 ;
    public final void rule__CreateTriggerStatement__Group_5_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10955:1: ( rule__CreateTriggerStatement__Group_5_2_1__0__Impl rule__CreateTriggerStatement__Group_5_2_1__1 )
            // InternalMickeyLang.g:10956:2: rule__CreateTriggerStatement__Group_5_2_1__0__Impl rule__CreateTriggerStatement__Group_5_2_1__1
            {
            pushFollow(FOLLOW_3);
            rule__CreateTriggerStatement__Group_5_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1__0__Impl"
    // InternalMickeyLang.g:10963:1: rule__CreateTriggerStatement__Group_5_2_1__0__Impl : ( 'of' ) ;
    public final void rule__CreateTriggerStatement__Group_5_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10967:1: ( ( 'of' ) )
            // InternalMickeyLang.g:10968:1: ( 'of' )
            {
            // InternalMickeyLang.g:10968:1: ( 'of' )
            // InternalMickeyLang.g:10969:2: 'of'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getOfKeyword_5_2_1_0()); 
            }
            match(input,98,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getOfKeyword_5_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1__1"
    // InternalMickeyLang.g:10978:1: rule__CreateTriggerStatement__Group_5_2_1__1 : rule__CreateTriggerStatement__Group_5_2_1__1__Impl rule__CreateTriggerStatement__Group_5_2_1__2 ;
    public final void rule__CreateTriggerStatement__Group_5_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10982:1: ( rule__CreateTriggerStatement__Group_5_2_1__1__Impl rule__CreateTriggerStatement__Group_5_2_1__2 )
            // InternalMickeyLang.g:10983:2: rule__CreateTriggerStatement__Group_5_2_1__1__Impl rule__CreateTriggerStatement__Group_5_2_1__2
            {
            pushFollow(FOLLOW_11);
            rule__CreateTriggerStatement__Group_5_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1__1__Impl"
    // InternalMickeyLang.g:10990:1: rule__CreateTriggerStatement__Group_5_2_1__1__Impl : ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 ) ) ;
    public final void rule__CreateTriggerStatement__Group_5_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:10994:1: ( ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 ) ) )
            // InternalMickeyLang.g:10995:1: ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 ) )
            {
            // InternalMickeyLang.g:10995:1: ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 ) )
            // InternalMickeyLang.g:10996:2: ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesAssignment_5_2_1_1()); 
            }
            // InternalMickeyLang.g:10997:2: ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 )
            // InternalMickeyLang.g:10997:3: rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesAssignment_5_2_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1__1__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1__2"
    // InternalMickeyLang.g:11005:1: rule__CreateTriggerStatement__Group_5_2_1__2 : rule__CreateTriggerStatement__Group_5_2_1__2__Impl ;
    public final void rule__CreateTriggerStatement__Group_5_2_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11009:1: ( rule__CreateTriggerStatement__Group_5_2_1__2__Impl )
            // InternalMickeyLang.g:11010:2: rule__CreateTriggerStatement__Group_5_2_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1__2"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1__2__Impl"
    // InternalMickeyLang.g:11016:1: rule__CreateTriggerStatement__Group_5_2_1__2__Impl : ( ( rule__CreateTriggerStatement__Group_5_2_1_2__0 )* ) ;
    public final void rule__CreateTriggerStatement__Group_5_2_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11020:1: ( ( ( rule__CreateTriggerStatement__Group_5_2_1_2__0 )* ) )
            // InternalMickeyLang.g:11021:1: ( ( rule__CreateTriggerStatement__Group_5_2_1_2__0 )* )
            {
            // InternalMickeyLang.g:11021:1: ( ( rule__CreateTriggerStatement__Group_5_2_1_2__0 )* )
            // InternalMickeyLang.g:11022:2: ( rule__CreateTriggerStatement__Group_5_2_1_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getGroup_5_2_1_2()); 
            }
            // InternalMickeyLang.g:11023:2: ( rule__CreateTriggerStatement__Group_5_2_1_2__0 )*
            loop99:
            do {
                int alt99=2;
                int LA99_0 = input.LA(1);

                if ( (LA99_0==40) ) {
                    alt99=1;
                }


                switch (alt99) {
            	case 1 :
            	    // InternalMickeyLang.g:11023:3: rule__CreateTriggerStatement__Group_5_2_1_2__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__CreateTriggerStatement__Group_5_2_1_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop99;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getGroup_5_2_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1__2__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1_2__0"
    // InternalMickeyLang.g:11032:1: rule__CreateTriggerStatement__Group_5_2_1_2__0 : rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl rule__CreateTriggerStatement__Group_5_2_1_2__1 ;
    public final void rule__CreateTriggerStatement__Group_5_2_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11036:1: ( rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl rule__CreateTriggerStatement__Group_5_2_1_2__1 )
            // InternalMickeyLang.g:11037:2: rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl rule__CreateTriggerStatement__Group_5_2_1_2__1
            {
            pushFollow(FOLLOW_3);
            rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1_2__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl"
    // InternalMickeyLang.g:11044:1: rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl : ( ',' ) ;
    public final void rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11048:1: ( ( ',' ) )
            // InternalMickeyLang.g:11049:1: ( ',' )
            {
            // InternalMickeyLang.g:11049:1: ( ',' )
            // InternalMickeyLang.g:11050:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getCommaKeyword_5_2_1_2_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getCommaKeyword_5_2_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1_2__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1_2__1"
    // InternalMickeyLang.g:11059:1: rule__CreateTriggerStatement__Group_5_2_1_2__1 : rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl ;
    public final void rule__CreateTriggerStatement__Group_5_2_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11063:1: ( rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl )
            // InternalMickeyLang.g:11064:2: rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1_2__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl"
    // InternalMickeyLang.g:11070:1: rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl : ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 ) ) ;
    public final void rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11074:1: ( ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 ) ) )
            // InternalMickeyLang.g:11075:1: ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 ) )
            {
            // InternalMickeyLang.g:11075:1: ( ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 ) )
            // InternalMickeyLang.g:11076:2: ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesAssignment_5_2_1_2_1()); 
            }
            // InternalMickeyLang.g:11077:2: ( rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 )
            // InternalMickeyLang.g:11077:3: rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesAssignment_5_2_1_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_5_2_1_2__1__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_9__0"
    // InternalMickeyLang.g:11086:1: rule__CreateTriggerStatement__Group_9__0 : rule__CreateTriggerStatement__Group_9__0__Impl rule__CreateTriggerStatement__Group_9__1 ;
    public final void rule__CreateTriggerStatement__Group_9__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11090:1: ( rule__CreateTriggerStatement__Group_9__0__Impl rule__CreateTriggerStatement__Group_9__1 )
            // InternalMickeyLang.g:11091:2: rule__CreateTriggerStatement__Group_9__0__Impl rule__CreateTriggerStatement__Group_9__1
            {
            pushFollow(FOLLOW_30);
            rule__CreateTriggerStatement__Group_9__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_9__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_9__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group_9__0__Impl"
    // InternalMickeyLang.g:11098:1: rule__CreateTriggerStatement__Group_9__0__Impl : ( 'when' ) ;
    public final void rule__CreateTriggerStatement__Group_9__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11102:1: ( ( 'when' ) )
            // InternalMickeyLang.g:11103:1: ( 'when' )
            {
            // InternalMickeyLang.g:11103:1: ( 'when' )
            // InternalMickeyLang.g:11104:2: 'when'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getWhenKeyword_9_0()); 
            }
            match(input,84,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getWhenKeyword_9_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_9__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_9__1"
    // InternalMickeyLang.g:11113:1: rule__CreateTriggerStatement__Group_9__1 : rule__CreateTriggerStatement__Group_9__1__Impl ;
    public final void rule__CreateTriggerStatement__Group_9__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11117:1: ( rule__CreateTriggerStatement__Group_9__1__Impl )
            // InternalMickeyLang.g:11118:2: rule__CreateTriggerStatement__Group_9__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_9__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_9__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group_9__1__Impl"
    // InternalMickeyLang.g:11124:1: rule__CreateTriggerStatement__Group_9__1__Impl : ( ( rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 ) ) ;
    public final void rule__CreateTriggerStatement__Group_9__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11128:1: ( ( ( rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 ) ) )
            // InternalMickeyLang.g:11129:1: ( ( rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 ) )
            {
            // InternalMickeyLang.g:11129:1: ( ( rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 ) )
            // InternalMickeyLang.g:11130:2: ( rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getWhenExpressionAssignment_9_1()); 
            }
            // InternalMickeyLang.g:11131:2: ( rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 )
            // InternalMickeyLang.g:11131:3: rule__CreateTriggerStatement__WhenExpressionAssignment_9_1
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__WhenExpressionAssignment_9_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getWhenExpressionAssignment_9_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_9__1__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11__0"
    // InternalMickeyLang.g:11140:1: rule__CreateTriggerStatement__Group_11__0 : rule__CreateTriggerStatement__Group_11__0__Impl rule__CreateTriggerStatement__Group_11__1 ;
    public final void rule__CreateTriggerStatement__Group_11__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11144:1: ( rule__CreateTriggerStatement__Group_11__0__Impl rule__CreateTriggerStatement__Group_11__1 )
            // InternalMickeyLang.g:11145:2: rule__CreateTriggerStatement__Group_11__0__Impl rule__CreateTriggerStatement__Group_11__1
            {
            pushFollow(FOLLOW_14);
            rule__CreateTriggerStatement__Group_11__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_11__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11__0__Impl"
    // InternalMickeyLang.g:11152:1: rule__CreateTriggerStatement__Group_11__0__Impl : ( ( rule__CreateTriggerStatement__StatementsAssignment_11_0 ) ) ;
    public final void rule__CreateTriggerStatement__Group_11__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11156:1: ( ( ( rule__CreateTriggerStatement__StatementsAssignment_11_0 ) ) )
            // InternalMickeyLang.g:11157:1: ( ( rule__CreateTriggerStatement__StatementsAssignment_11_0 ) )
            {
            // InternalMickeyLang.g:11157:1: ( ( rule__CreateTriggerStatement__StatementsAssignment_11_0 ) )
            // InternalMickeyLang.g:11158:2: ( rule__CreateTriggerStatement__StatementsAssignment_11_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getStatementsAssignment_11_0()); 
            }
            // InternalMickeyLang.g:11159:2: ( rule__CreateTriggerStatement__StatementsAssignment_11_0 )
            // InternalMickeyLang.g:11159:3: rule__CreateTriggerStatement__StatementsAssignment_11_0
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__StatementsAssignment_11_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getStatementsAssignment_11_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11__1"
    // InternalMickeyLang.g:11167:1: rule__CreateTriggerStatement__Group_11__1 : rule__CreateTriggerStatement__Group_11__1__Impl rule__CreateTriggerStatement__Group_11__2 ;
    public final void rule__CreateTriggerStatement__Group_11__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11171:1: ( rule__CreateTriggerStatement__Group_11__1__Impl rule__CreateTriggerStatement__Group_11__2 )
            // InternalMickeyLang.g:11172:2: rule__CreateTriggerStatement__Group_11__1__Impl rule__CreateTriggerStatement__Group_11__2
            {
            pushFollow(FOLLOW_90);
            rule__CreateTriggerStatement__Group_11__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_11__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11__1__Impl"
    // InternalMickeyLang.g:11179:1: rule__CreateTriggerStatement__Group_11__1__Impl : ( ';' ) ;
    public final void rule__CreateTriggerStatement__Group_11__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11183:1: ( ( ';' ) )
            // InternalMickeyLang.g:11184:1: ( ';' )
            {
            // InternalMickeyLang.g:11184:1: ( ';' )
            // InternalMickeyLang.g:11185:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getSemicolonKeyword_11_1()); 
            }
            match(input,67,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getSemicolonKeyword_11_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11__1__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11__2"
    // InternalMickeyLang.g:11194:1: rule__CreateTriggerStatement__Group_11__2 : rule__CreateTriggerStatement__Group_11__2__Impl ;
    public final void rule__CreateTriggerStatement__Group_11__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11198:1: ( rule__CreateTriggerStatement__Group_11__2__Impl )
            // InternalMickeyLang.g:11199:2: rule__CreateTriggerStatement__Group_11__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_11__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11__2"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11__2__Impl"
    // InternalMickeyLang.g:11205:1: rule__CreateTriggerStatement__Group_11__2__Impl : ( ( rule__CreateTriggerStatement__Group_11_2__0 )* ) ;
    public final void rule__CreateTriggerStatement__Group_11__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11209:1: ( ( ( rule__CreateTriggerStatement__Group_11_2__0 )* ) )
            // InternalMickeyLang.g:11210:1: ( ( rule__CreateTriggerStatement__Group_11_2__0 )* )
            {
            // InternalMickeyLang.g:11210:1: ( ( rule__CreateTriggerStatement__Group_11_2__0 )* )
            // InternalMickeyLang.g:11211:2: ( rule__CreateTriggerStatement__Group_11_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getGroup_11_2()); 
            }
            // InternalMickeyLang.g:11212:2: ( rule__CreateTriggerStatement__Group_11_2__0 )*
            loop100:
            do {
                int alt100=2;
                int LA100_0 = input.LA(1);

                if ( (LA100_0==44||LA100_0==88||LA100_0==111||LA100_0==113||LA100_0==116) ) {
                    alt100=1;
                }


                switch (alt100) {
            	case 1 :
            	    // InternalMickeyLang.g:11212:3: rule__CreateTriggerStatement__Group_11_2__0
            	    {
            	    pushFollow(FOLLOW_10);
            	    rule__CreateTriggerStatement__Group_11_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop100;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getGroup_11_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11__2__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11_2__0"
    // InternalMickeyLang.g:11221:1: rule__CreateTriggerStatement__Group_11_2__0 : rule__CreateTriggerStatement__Group_11_2__0__Impl rule__CreateTriggerStatement__Group_11_2__1 ;
    public final void rule__CreateTriggerStatement__Group_11_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11225:1: ( rule__CreateTriggerStatement__Group_11_2__0__Impl rule__CreateTriggerStatement__Group_11_2__1 )
            // InternalMickeyLang.g:11226:2: rule__CreateTriggerStatement__Group_11_2__0__Impl rule__CreateTriggerStatement__Group_11_2__1
            {
            pushFollow(FOLLOW_14);
            rule__CreateTriggerStatement__Group_11_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_11_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11_2__0"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11_2__0__Impl"
    // InternalMickeyLang.g:11233:1: rule__CreateTriggerStatement__Group_11_2__0__Impl : ( ( rule__CreateTriggerStatement__StatementsAssignment_11_2_0 ) ) ;
    public final void rule__CreateTriggerStatement__Group_11_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11237:1: ( ( ( rule__CreateTriggerStatement__StatementsAssignment_11_2_0 ) ) )
            // InternalMickeyLang.g:11238:1: ( ( rule__CreateTriggerStatement__StatementsAssignment_11_2_0 ) )
            {
            // InternalMickeyLang.g:11238:1: ( ( rule__CreateTriggerStatement__StatementsAssignment_11_2_0 ) )
            // InternalMickeyLang.g:11239:2: ( rule__CreateTriggerStatement__StatementsAssignment_11_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getStatementsAssignment_11_2_0()); 
            }
            // InternalMickeyLang.g:11240:2: ( rule__CreateTriggerStatement__StatementsAssignment_11_2_0 )
            // InternalMickeyLang.g:11240:3: rule__CreateTriggerStatement__StatementsAssignment_11_2_0
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__StatementsAssignment_11_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getStatementsAssignment_11_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11_2__0__Impl"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11_2__1"
    // InternalMickeyLang.g:11248:1: rule__CreateTriggerStatement__Group_11_2__1 : rule__CreateTriggerStatement__Group_11_2__1__Impl ;
    public final void rule__CreateTriggerStatement__Group_11_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11252:1: ( rule__CreateTriggerStatement__Group_11_2__1__Impl )
            // InternalMickeyLang.g:11253:2: rule__CreateTriggerStatement__Group_11_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__Group_11_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11_2__1"


    // $ANTLR start "rule__CreateTriggerStatement__Group_11_2__1__Impl"
    // InternalMickeyLang.g:11259:1: rule__CreateTriggerStatement__Group_11_2__1__Impl : ( ';' ) ;
    public final void rule__CreateTriggerStatement__Group_11_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11263:1: ( ( ';' ) )
            // InternalMickeyLang.g:11264:1: ( ';' )
            {
            // InternalMickeyLang.g:11264:1: ( ';' )
            // InternalMickeyLang.g:11265:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getSemicolonKeyword_11_2_1()); 
            }
            match(input,67,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getSemicolonKeyword_11_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__Group_11_2__1__Impl"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__0"
    // InternalMickeyLang.g:11275:1: rule__AlterTableRenameStatement__Group__0 : rule__AlterTableRenameStatement__Group__0__Impl rule__AlterTableRenameStatement__Group__1 ;
    public final void rule__AlterTableRenameStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11279:1: ( rule__AlterTableRenameStatement__Group__0__Impl rule__AlterTableRenameStatement__Group__1 )
            // InternalMickeyLang.g:11280:2: rule__AlterTableRenameStatement__Group__0__Impl rule__AlterTableRenameStatement__Group__1
            {
            pushFollow(FOLLOW_91);
            rule__AlterTableRenameStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__0"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__0__Impl"
    // InternalMickeyLang.g:11287:1: rule__AlterTableRenameStatement__Group__0__Impl : ( () ) ;
    public final void rule__AlterTableRenameStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11291:1: ( ( () ) )
            // InternalMickeyLang.g:11292:1: ( () )
            {
            // InternalMickeyLang.g:11292:1: ( () )
            // InternalMickeyLang.g:11293:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getAlterTableRenameStatementAction_0()); 
            }
            // InternalMickeyLang.g:11294:2: ()
            // InternalMickeyLang.g:11294:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getAlterTableRenameStatementAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__0__Impl"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__1"
    // InternalMickeyLang.g:11302:1: rule__AlterTableRenameStatement__Group__1 : rule__AlterTableRenameStatement__Group__1__Impl rule__AlterTableRenameStatement__Group__2 ;
    public final void rule__AlterTableRenameStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11306:1: ( rule__AlterTableRenameStatement__Group__1__Impl rule__AlterTableRenameStatement__Group__2 )
            // InternalMickeyLang.g:11307:2: rule__AlterTableRenameStatement__Group__1__Impl rule__AlterTableRenameStatement__Group__2
            {
            pushFollow(FOLLOW_92);
            rule__AlterTableRenameStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__1"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__1__Impl"
    // InternalMickeyLang.g:11314:1: rule__AlterTableRenameStatement__Group__1__Impl : ( 'alter' ) ;
    public final void rule__AlterTableRenameStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11318:1: ( ( 'alter' ) )
            // InternalMickeyLang.g:11319:1: ( 'alter' )
            {
            // InternalMickeyLang.g:11319:1: ( 'alter' )
            // InternalMickeyLang.g:11320:2: 'alter'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getAlterKeyword_1()); 
            }
            match(input,99,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getAlterKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__1__Impl"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__2"
    // InternalMickeyLang.g:11329:1: rule__AlterTableRenameStatement__Group__2 : rule__AlterTableRenameStatement__Group__2__Impl rule__AlterTableRenameStatement__Group__3 ;
    public final void rule__AlterTableRenameStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11333:1: ( rule__AlterTableRenameStatement__Group__2__Impl rule__AlterTableRenameStatement__Group__3 )
            // InternalMickeyLang.g:11334:2: rule__AlterTableRenameStatement__Group__2__Impl rule__AlterTableRenameStatement__Group__3
            {
            pushFollow(FOLLOW_3);
            rule__AlterTableRenameStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__2"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__2__Impl"
    // InternalMickeyLang.g:11341:1: rule__AlterTableRenameStatement__Group__2__Impl : ( 'table' ) ;
    public final void rule__AlterTableRenameStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11345:1: ( ( 'table' ) )
            // InternalMickeyLang.g:11346:1: ( 'table' )
            {
            // InternalMickeyLang.g:11346:1: ( 'table' )
            // InternalMickeyLang.g:11347:2: 'table'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getTableKeyword_2()); 
            }
            match(input,94,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getTableKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__2__Impl"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__3"
    // InternalMickeyLang.g:11356:1: rule__AlterTableRenameStatement__Group__3 : rule__AlterTableRenameStatement__Group__3__Impl rule__AlterTableRenameStatement__Group__4 ;
    public final void rule__AlterTableRenameStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11360:1: ( rule__AlterTableRenameStatement__Group__3__Impl rule__AlterTableRenameStatement__Group__4 )
            // InternalMickeyLang.g:11361:2: rule__AlterTableRenameStatement__Group__3__Impl rule__AlterTableRenameStatement__Group__4
            {
            pushFollow(FOLLOW_93);
            rule__AlterTableRenameStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__3"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__3__Impl"
    // InternalMickeyLang.g:11368:1: rule__AlterTableRenameStatement__Group__3__Impl : ( ( rule__AlterTableRenameStatement__TableAssignment_3 ) ) ;
    public final void rule__AlterTableRenameStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11372:1: ( ( ( rule__AlterTableRenameStatement__TableAssignment_3 ) ) )
            // InternalMickeyLang.g:11373:1: ( ( rule__AlterTableRenameStatement__TableAssignment_3 ) )
            {
            // InternalMickeyLang.g:11373:1: ( ( rule__AlterTableRenameStatement__TableAssignment_3 ) )
            // InternalMickeyLang.g:11374:2: ( rule__AlterTableRenameStatement__TableAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getTableAssignment_3()); 
            }
            // InternalMickeyLang.g:11375:2: ( rule__AlterTableRenameStatement__TableAssignment_3 )
            // InternalMickeyLang.g:11375:3: rule__AlterTableRenameStatement__TableAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__TableAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getTableAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__3__Impl"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__4"
    // InternalMickeyLang.g:11383:1: rule__AlterTableRenameStatement__Group__4 : rule__AlterTableRenameStatement__Group__4__Impl rule__AlterTableRenameStatement__Group__5 ;
    public final void rule__AlterTableRenameStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11387:1: ( rule__AlterTableRenameStatement__Group__4__Impl rule__AlterTableRenameStatement__Group__5 )
            // InternalMickeyLang.g:11388:2: rule__AlterTableRenameStatement__Group__4__Impl rule__AlterTableRenameStatement__Group__5
            {
            pushFollow(FOLLOW_3);
            rule__AlterTableRenameStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__4"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__4__Impl"
    // InternalMickeyLang.g:11395:1: rule__AlterTableRenameStatement__Group__4__Impl : ( 'rename to' ) ;
    public final void rule__AlterTableRenameStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11399:1: ( ( 'rename to' ) )
            // InternalMickeyLang.g:11400:1: ( 'rename to' )
            {
            // InternalMickeyLang.g:11400:1: ( 'rename to' )
            // InternalMickeyLang.g:11401:2: 'rename to'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getRenameToKeyword_4()); 
            }
            match(input,100,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getRenameToKeyword_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__4__Impl"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__5"
    // InternalMickeyLang.g:11410:1: rule__AlterTableRenameStatement__Group__5 : rule__AlterTableRenameStatement__Group__5__Impl ;
    public final void rule__AlterTableRenameStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11414:1: ( rule__AlterTableRenameStatement__Group__5__Impl )
            // InternalMickeyLang.g:11415:2: rule__AlterTableRenameStatement__Group__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__5"


    // $ANTLR start "rule__AlterTableRenameStatement__Group__5__Impl"
    // InternalMickeyLang.g:11421:1: rule__AlterTableRenameStatement__Group__5__Impl : ( ( rule__AlterTableRenameStatement__NameAssignment_5 ) ) ;
    public final void rule__AlterTableRenameStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11425:1: ( ( ( rule__AlterTableRenameStatement__NameAssignment_5 ) ) )
            // InternalMickeyLang.g:11426:1: ( ( rule__AlterTableRenameStatement__NameAssignment_5 ) )
            {
            // InternalMickeyLang.g:11426:1: ( ( rule__AlterTableRenameStatement__NameAssignment_5 ) )
            // InternalMickeyLang.g:11427:2: ( rule__AlterTableRenameStatement__NameAssignment_5 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getNameAssignment_5()); 
            }
            // InternalMickeyLang.g:11428:2: ( rule__AlterTableRenameStatement__NameAssignment_5 )
            // InternalMickeyLang.g:11428:3: rule__AlterTableRenameStatement__NameAssignment_5
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableRenameStatement__NameAssignment_5();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getNameAssignment_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__Group__5__Impl"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__0"
    // InternalMickeyLang.g:11437:1: rule__AlterTableAddColumnStatement__Group__0 : rule__AlterTableAddColumnStatement__Group__0__Impl rule__AlterTableAddColumnStatement__Group__1 ;
    public final void rule__AlterTableAddColumnStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11441:1: ( rule__AlterTableAddColumnStatement__Group__0__Impl rule__AlterTableAddColumnStatement__Group__1 )
            // InternalMickeyLang.g:11442:2: rule__AlterTableAddColumnStatement__Group__0__Impl rule__AlterTableAddColumnStatement__Group__1
            {
            pushFollow(FOLLOW_92);
            rule__AlterTableAddColumnStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__0"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__0__Impl"
    // InternalMickeyLang.g:11449:1: rule__AlterTableAddColumnStatement__Group__0__Impl : ( 'alter' ) ;
    public final void rule__AlterTableAddColumnStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11453:1: ( ( 'alter' ) )
            // InternalMickeyLang.g:11454:1: ( 'alter' )
            {
            // InternalMickeyLang.g:11454:1: ( 'alter' )
            // InternalMickeyLang.g:11455:2: 'alter'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getAlterKeyword_0()); 
            }
            match(input,99,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getAlterKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__0__Impl"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__1"
    // InternalMickeyLang.g:11464:1: rule__AlterTableAddColumnStatement__Group__1 : rule__AlterTableAddColumnStatement__Group__1__Impl rule__AlterTableAddColumnStatement__Group__2 ;
    public final void rule__AlterTableAddColumnStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11468:1: ( rule__AlterTableAddColumnStatement__Group__1__Impl rule__AlterTableAddColumnStatement__Group__2 )
            // InternalMickeyLang.g:11469:2: rule__AlterTableAddColumnStatement__Group__1__Impl rule__AlterTableAddColumnStatement__Group__2
            {
            pushFollow(FOLLOW_3);
            rule__AlterTableAddColumnStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__1"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__1__Impl"
    // InternalMickeyLang.g:11476:1: rule__AlterTableAddColumnStatement__Group__1__Impl : ( 'table' ) ;
    public final void rule__AlterTableAddColumnStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11480:1: ( ( 'table' ) )
            // InternalMickeyLang.g:11481:1: ( 'table' )
            {
            // InternalMickeyLang.g:11481:1: ( 'table' )
            // InternalMickeyLang.g:11482:2: 'table'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getTableKeyword_1()); 
            }
            match(input,94,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getTableKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__1__Impl"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__2"
    // InternalMickeyLang.g:11491:1: rule__AlterTableAddColumnStatement__Group__2 : rule__AlterTableAddColumnStatement__Group__2__Impl rule__AlterTableAddColumnStatement__Group__3 ;
    public final void rule__AlterTableAddColumnStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11495:1: ( rule__AlterTableAddColumnStatement__Group__2__Impl rule__AlterTableAddColumnStatement__Group__3 )
            // InternalMickeyLang.g:11496:2: rule__AlterTableAddColumnStatement__Group__2__Impl rule__AlterTableAddColumnStatement__Group__3
            {
            pushFollow(FOLLOW_94);
            rule__AlterTableAddColumnStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__2"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__2__Impl"
    // InternalMickeyLang.g:11503:1: rule__AlterTableAddColumnStatement__Group__2__Impl : ( ( rule__AlterTableAddColumnStatement__TableAssignment_2 ) ) ;
    public final void rule__AlterTableAddColumnStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11507:1: ( ( ( rule__AlterTableAddColumnStatement__TableAssignment_2 ) ) )
            // InternalMickeyLang.g:11508:1: ( ( rule__AlterTableAddColumnStatement__TableAssignment_2 ) )
            {
            // InternalMickeyLang.g:11508:1: ( ( rule__AlterTableAddColumnStatement__TableAssignment_2 ) )
            // InternalMickeyLang.g:11509:2: ( rule__AlterTableAddColumnStatement__TableAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getTableAssignment_2()); 
            }
            // InternalMickeyLang.g:11510:2: ( rule__AlterTableAddColumnStatement__TableAssignment_2 )
            // InternalMickeyLang.g:11510:3: rule__AlterTableAddColumnStatement__TableAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__TableAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getTableAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__2__Impl"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__3"
    // InternalMickeyLang.g:11518:1: rule__AlterTableAddColumnStatement__Group__3 : rule__AlterTableAddColumnStatement__Group__3__Impl rule__AlterTableAddColumnStatement__Group__4 ;
    public final void rule__AlterTableAddColumnStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11522:1: ( rule__AlterTableAddColumnStatement__Group__3__Impl rule__AlterTableAddColumnStatement__Group__4 )
            // InternalMickeyLang.g:11523:2: rule__AlterTableAddColumnStatement__Group__3__Impl rule__AlterTableAddColumnStatement__Group__4
            {
            pushFollow(FOLLOW_3);
            rule__AlterTableAddColumnStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__3"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__3__Impl"
    // InternalMickeyLang.g:11530:1: rule__AlterTableAddColumnStatement__Group__3__Impl : ( 'add column' ) ;
    public final void rule__AlterTableAddColumnStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11534:1: ( ( 'add column' ) )
            // InternalMickeyLang.g:11535:1: ( 'add column' )
            {
            // InternalMickeyLang.g:11535:1: ( 'add column' )
            // InternalMickeyLang.g:11536:2: 'add column'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getAddColumnKeyword_3()); 
            }
            match(input,101,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getAddColumnKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__3__Impl"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__4"
    // InternalMickeyLang.g:11545:1: rule__AlterTableAddColumnStatement__Group__4 : rule__AlterTableAddColumnStatement__Group__4__Impl ;
    public final void rule__AlterTableAddColumnStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11549:1: ( rule__AlterTableAddColumnStatement__Group__4__Impl )
            // InternalMickeyLang.g:11550:2: rule__AlterTableAddColumnStatement__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__4"


    // $ANTLR start "rule__AlterTableAddColumnStatement__Group__4__Impl"
    // InternalMickeyLang.g:11556:1: rule__AlterTableAddColumnStatement__Group__4__Impl : ( ( rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 ) ) ;
    public final void rule__AlterTableAddColumnStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11560:1: ( ( ( rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 ) ) )
            // InternalMickeyLang.g:11561:1: ( ( rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 ) )
            {
            // InternalMickeyLang.g:11561:1: ( ( rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 ) )
            // InternalMickeyLang.g:11562:2: ( rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getColumnDefAssignment_4()); 
            }
            // InternalMickeyLang.g:11563:2: ( rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 )
            // InternalMickeyLang.g:11563:3: rule__AlterTableAddColumnStatement__ColumnDefAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__AlterTableAddColumnStatement__ColumnDefAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getColumnDefAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__Group__4__Impl"


    // $ANTLR start "rule__DropTableStatement__Group__0"
    // InternalMickeyLang.g:11572:1: rule__DropTableStatement__Group__0 : rule__DropTableStatement__Group__0__Impl rule__DropTableStatement__Group__1 ;
    public final void rule__DropTableStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11576:1: ( rule__DropTableStatement__Group__0__Impl rule__DropTableStatement__Group__1 )
            // InternalMickeyLang.g:11577:2: rule__DropTableStatement__Group__0__Impl rule__DropTableStatement__Group__1
            {
            pushFollow(FOLLOW_92);
            rule__DropTableStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropTableStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__0"


    // $ANTLR start "rule__DropTableStatement__Group__0__Impl"
    // InternalMickeyLang.g:11584:1: rule__DropTableStatement__Group__0__Impl : ( 'drop' ) ;
    public final void rule__DropTableStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11588:1: ( ( 'drop' ) )
            // InternalMickeyLang.g:11589:1: ( 'drop' )
            {
            // InternalMickeyLang.g:11589:1: ( 'drop' )
            // InternalMickeyLang.g:11590:2: 'drop'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getDropKeyword_0()); 
            }
            match(input,102,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getDropKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__0__Impl"


    // $ANTLR start "rule__DropTableStatement__Group__1"
    // InternalMickeyLang.g:11599:1: rule__DropTableStatement__Group__1 : rule__DropTableStatement__Group__1__Impl rule__DropTableStatement__Group__2 ;
    public final void rule__DropTableStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11603:1: ( rule__DropTableStatement__Group__1__Impl rule__DropTableStatement__Group__2 )
            // InternalMickeyLang.g:11604:2: rule__DropTableStatement__Group__1__Impl rule__DropTableStatement__Group__2
            {
            pushFollow(FOLLOW_95);
            rule__DropTableStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropTableStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__1"


    // $ANTLR start "rule__DropTableStatement__Group__1__Impl"
    // InternalMickeyLang.g:11611:1: rule__DropTableStatement__Group__1__Impl : ( 'table' ) ;
    public final void rule__DropTableStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11615:1: ( ( 'table' ) )
            // InternalMickeyLang.g:11616:1: ( 'table' )
            {
            // InternalMickeyLang.g:11616:1: ( 'table' )
            // InternalMickeyLang.g:11617:2: 'table'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getTableKeyword_1()); 
            }
            match(input,94,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getTableKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__1__Impl"


    // $ANTLR start "rule__DropTableStatement__Group__2"
    // InternalMickeyLang.g:11626:1: rule__DropTableStatement__Group__2 : rule__DropTableStatement__Group__2__Impl rule__DropTableStatement__Group__3 ;
    public final void rule__DropTableStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11630:1: ( rule__DropTableStatement__Group__2__Impl rule__DropTableStatement__Group__3 )
            // InternalMickeyLang.g:11631:2: rule__DropTableStatement__Group__2__Impl rule__DropTableStatement__Group__3
            {
            pushFollow(FOLLOW_95);
            rule__DropTableStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropTableStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__2"


    // $ANTLR start "rule__DropTableStatement__Group__2__Impl"
    // InternalMickeyLang.g:11638:1: rule__DropTableStatement__Group__2__Impl : ( ( rule__DropTableStatement__IfExistsAssignment_2 )? ) ;
    public final void rule__DropTableStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11642:1: ( ( ( rule__DropTableStatement__IfExistsAssignment_2 )? ) )
            // InternalMickeyLang.g:11643:1: ( ( rule__DropTableStatement__IfExistsAssignment_2 )? )
            {
            // InternalMickeyLang.g:11643:1: ( ( rule__DropTableStatement__IfExistsAssignment_2 )? )
            // InternalMickeyLang.g:11644:2: ( rule__DropTableStatement__IfExistsAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getIfExistsAssignment_2()); 
            }
            // InternalMickeyLang.g:11645:2: ( rule__DropTableStatement__IfExistsAssignment_2 )?
            int alt101=2;
            int LA101_0 = input.LA(1);

            if ( (LA101_0==137) ) {
                alt101=1;
            }
            switch (alt101) {
                case 1 :
                    // InternalMickeyLang.g:11645:3: rule__DropTableStatement__IfExistsAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__DropTableStatement__IfExistsAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getIfExistsAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__2__Impl"


    // $ANTLR start "rule__DropTableStatement__Group__3"
    // InternalMickeyLang.g:11653:1: rule__DropTableStatement__Group__3 : rule__DropTableStatement__Group__3__Impl ;
    public final void rule__DropTableStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11657:1: ( rule__DropTableStatement__Group__3__Impl )
            // InternalMickeyLang.g:11658:2: rule__DropTableStatement__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DropTableStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__3"


    // $ANTLR start "rule__DropTableStatement__Group__3__Impl"
    // InternalMickeyLang.g:11664:1: rule__DropTableStatement__Group__3__Impl : ( ( rule__DropTableStatement__TableAssignment_3 ) ) ;
    public final void rule__DropTableStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11668:1: ( ( ( rule__DropTableStatement__TableAssignment_3 ) ) )
            // InternalMickeyLang.g:11669:1: ( ( rule__DropTableStatement__TableAssignment_3 ) )
            {
            // InternalMickeyLang.g:11669:1: ( ( rule__DropTableStatement__TableAssignment_3 ) )
            // InternalMickeyLang.g:11670:2: ( rule__DropTableStatement__TableAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getTableAssignment_3()); 
            }
            // InternalMickeyLang.g:11671:2: ( rule__DropTableStatement__TableAssignment_3 )
            // InternalMickeyLang.g:11671:3: rule__DropTableStatement__TableAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__DropTableStatement__TableAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getTableAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__Group__3__Impl"


    // $ANTLR start "rule__DropTriggerStatement__Group__0"
    // InternalMickeyLang.g:11680:1: rule__DropTriggerStatement__Group__0 : rule__DropTriggerStatement__Group__0__Impl rule__DropTriggerStatement__Group__1 ;
    public final void rule__DropTriggerStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11684:1: ( rule__DropTriggerStatement__Group__0__Impl rule__DropTriggerStatement__Group__1 )
            // InternalMickeyLang.g:11685:2: rule__DropTriggerStatement__Group__0__Impl rule__DropTriggerStatement__Group__1
            {
            pushFollow(FOLLOW_96);
            rule__DropTriggerStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropTriggerStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__0"


    // $ANTLR start "rule__DropTriggerStatement__Group__0__Impl"
    // InternalMickeyLang.g:11692:1: rule__DropTriggerStatement__Group__0__Impl : ( 'drop' ) ;
    public final void rule__DropTriggerStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11696:1: ( ( 'drop' ) )
            // InternalMickeyLang.g:11697:1: ( 'drop' )
            {
            // InternalMickeyLang.g:11697:1: ( 'drop' )
            // InternalMickeyLang.g:11698:2: 'drop'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getDropKeyword_0()); 
            }
            match(input,102,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getDropKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__0__Impl"


    // $ANTLR start "rule__DropTriggerStatement__Group__1"
    // InternalMickeyLang.g:11707:1: rule__DropTriggerStatement__Group__1 : rule__DropTriggerStatement__Group__1__Impl rule__DropTriggerStatement__Group__2 ;
    public final void rule__DropTriggerStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11711:1: ( rule__DropTriggerStatement__Group__1__Impl rule__DropTriggerStatement__Group__2 )
            // InternalMickeyLang.g:11712:2: rule__DropTriggerStatement__Group__1__Impl rule__DropTriggerStatement__Group__2
            {
            pushFollow(FOLLOW_95);
            rule__DropTriggerStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropTriggerStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__1"


    // $ANTLR start "rule__DropTriggerStatement__Group__1__Impl"
    // InternalMickeyLang.g:11719:1: rule__DropTriggerStatement__Group__1__Impl : ( 'trigger' ) ;
    public final void rule__DropTriggerStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11723:1: ( ( 'trigger' ) )
            // InternalMickeyLang.g:11724:1: ( 'trigger' )
            {
            // InternalMickeyLang.g:11724:1: ( 'trigger' )
            // InternalMickeyLang.g:11725:2: 'trigger'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getTriggerKeyword_1()); 
            }
            match(input,96,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getTriggerKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__1__Impl"


    // $ANTLR start "rule__DropTriggerStatement__Group__2"
    // InternalMickeyLang.g:11734:1: rule__DropTriggerStatement__Group__2 : rule__DropTriggerStatement__Group__2__Impl rule__DropTriggerStatement__Group__3 ;
    public final void rule__DropTriggerStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11738:1: ( rule__DropTriggerStatement__Group__2__Impl rule__DropTriggerStatement__Group__3 )
            // InternalMickeyLang.g:11739:2: rule__DropTriggerStatement__Group__2__Impl rule__DropTriggerStatement__Group__3
            {
            pushFollow(FOLLOW_95);
            rule__DropTriggerStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropTriggerStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__2"


    // $ANTLR start "rule__DropTriggerStatement__Group__2__Impl"
    // InternalMickeyLang.g:11746:1: rule__DropTriggerStatement__Group__2__Impl : ( ( rule__DropTriggerStatement__IfExistsAssignment_2 )? ) ;
    public final void rule__DropTriggerStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11750:1: ( ( ( rule__DropTriggerStatement__IfExistsAssignment_2 )? ) )
            // InternalMickeyLang.g:11751:1: ( ( rule__DropTriggerStatement__IfExistsAssignment_2 )? )
            {
            // InternalMickeyLang.g:11751:1: ( ( rule__DropTriggerStatement__IfExistsAssignment_2 )? )
            // InternalMickeyLang.g:11752:2: ( rule__DropTriggerStatement__IfExistsAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getIfExistsAssignment_2()); 
            }
            // InternalMickeyLang.g:11753:2: ( rule__DropTriggerStatement__IfExistsAssignment_2 )?
            int alt102=2;
            int LA102_0 = input.LA(1);

            if ( (LA102_0==137) ) {
                alt102=1;
            }
            switch (alt102) {
                case 1 :
                    // InternalMickeyLang.g:11753:3: rule__DropTriggerStatement__IfExistsAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__DropTriggerStatement__IfExistsAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getIfExistsAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__2__Impl"


    // $ANTLR start "rule__DropTriggerStatement__Group__3"
    // InternalMickeyLang.g:11761:1: rule__DropTriggerStatement__Group__3 : rule__DropTriggerStatement__Group__3__Impl ;
    public final void rule__DropTriggerStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11765:1: ( rule__DropTriggerStatement__Group__3__Impl )
            // InternalMickeyLang.g:11766:2: rule__DropTriggerStatement__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DropTriggerStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__3"


    // $ANTLR start "rule__DropTriggerStatement__Group__3__Impl"
    // InternalMickeyLang.g:11772:1: rule__DropTriggerStatement__Group__3__Impl : ( ( rule__DropTriggerStatement__TriggerAssignment_3 ) ) ;
    public final void rule__DropTriggerStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11776:1: ( ( ( rule__DropTriggerStatement__TriggerAssignment_3 ) ) )
            // InternalMickeyLang.g:11777:1: ( ( rule__DropTriggerStatement__TriggerAssignment_3 ) )
            {
            // InternalMickeyLang.g:11777:1: ( ( rule__DropTriggerStatement__TriggerAssignment_3 ) )
            // InternalMickeyLang.g:11778:2: ( rule__DropTriggerStatement__TriggerAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getTriggerAssignment_3()); 
            }
            // InternalMickeyLang.g:11779:2: ( rule__DropTriggerStatement__TriggerAssignment_3 )
            // InternalMickeyLang.g:11779:3: rule__DropTriggerStatement__TriggerAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__DropTriggerStatement__TriggerAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getTriggerAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__Group__3__Impl"


    // $ANTLR start "rule__DropViewStatement__Group__0"
    // InternalMickeyLang.g:11788:1: rule__DropViewStatement__Group__0 : rule__DropViewStatement__Group__0__Impl rule__DropViewStatement__Group__1 ;
    public final void rule__DropViewStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11792:1: ( rule__DropViewStatement__Group__0__Impl rule__DropViewStatement__Group__1 )
            // InternalMickeyLang.g:11793:2: rule__DropViewStatement__Group__0__Impl rule__DropViewStatement__Group__1
            {
            pushFollow(FOLLOW_97);
            rule__DropViewStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropViewStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__0"


    // $ANTLR start "rule__DropViewStatement__Group__0__Impl"
    // InternalMickeyLang.g:11800:1: rule__DropViewStatement__Group__0__Impl : ( 'drop' ) ;
    public final void rule__DropViewStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11804:1: ( ( 'drop' ) )
            // InternalMickeyLang.g:11805:1: ( 'drop' )
            {
            // InternalMickeyLang.g:11805:1: ( 'drop' )
            // InternalMickeyLang.g:11806:2: 'drop'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getDropKeyword_0()); 
            }
            match(input,102,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getDropKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__0__Impl"


    // $ANTLR start "rule__DropViewStatement__Group__1"
    // InternalMickeyLang.g:11815:1: rule__DropViewStatement__Group__1 : rule__DropViewStatement__Group__1__Impl rule__DropViewStatement__Group__2 ;
    public final void rule__DropViewStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11819:1: ( rule__DropViewStatement__Group__1__Impl rule__DropViewStatement__Group__2 )
            // InternalMickeyLang.g:11820:2: rule__DropViewStatement__Group__1__Impl rule__DropViewStatement__Group__2
            {
            pushFollow(FOLLOW_95);
            rule__DropViewStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropViewStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__1"


    // $ANTLR start "rule__DropViewStatement__Group__1__Impl"
    // InternalMickeyLang.g:11827:1: rule__DropViewStatement__Group__1__Impl : ( 'view' ) ;
    public final void rule__DropViewStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11831:1: ( ( 'view' ) )
            // InternalMickeyLang.g:11832:1: ( 'view' )
            {
            // InternalMickeyLang.g:11832:1: ( 'view' )
            // InternalMickeyLang.g:11833:2: 'view'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getViewKeyword_1()); 
            }
            match(input,95,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getViewKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__1__Impl"


    // $ANTLR start "rule__DropViewStatement__Group__2"
    // InternalMickeyLang.g:11842:1: rule__DropViewStatement__Group__2 : rule__DropViewStatement__Group__2__Impl rule__DropViewStatement__Group__3 ;
    public final void rule__DropViewStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11846:1: ( rule__DropViewStatement__Group__2__Impl rule__DropViewStatement__Group__3 )
            // InternalMickeyLang.g:11847:2: rule__DropViewStatement__Group__2__Impl rule__DropViewStatement__Group__3
            {
            pushFollow(FOLLOW_95);
            rule__DropViewStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropViewStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__2"


    // $ANTLR start "rule__DropViewStatement__Group__2__Impl"
    // InternalMickeyLang.g:11854:1: rule__DropViewStatement__Group__2__Impl : ( ( rule__DropViewStatement__IfExistsAssignment_2 )? ) ;
    public final void rule__DropViewStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11858:1: ( ( ( rule__DropViewStatement__IfExistsAssignment_2 )? ) )
            // InternalMickeyLang.g:11859:1: ( ( rule__DropViewStatement__IfExistsAssignment_2 )? )
            {
            // InternalMickeyLang.g:11859:1: ( ( rule__DropViewStatement__IfExistsAssignment_2 )? )
            // InternalMickeyLang.g:11860:2: ( rule__DropViewStatement__IfExistsAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getIfExistsAssignment_2()); 
            }
            // InternalMickeyLang.g:11861:2: ( rule__DropViewStatement__IfExistsAssignment_2 )?
            int alt103=2;
            int LA103_0 = input.LA(1);

            if ( (LA103_0==137) ) {
                alt103=1;
            }
            switch (alt103) {
                case 1 :
                    // InternalMickeyLang.g:11861:3: rule__DropViewStatement__IfExistsAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__DropViewStatement__IfExistsAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getIfExistsAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__2__Impl"


    // $ANTLR start "rule__DropViewStatement__Group__3"
    // InternalMickeyLang.g:11869:1: rule__DropViewStatement__Group__3 : rule__DropViewStatement__Group__3__Impl ;
    public final void rule__DropViewStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11873:1: ( rule__DropViewStatement__Group__3__Impl )
            // InternalMickeyLang.g:11874:2: rule__DropViewStatement__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DropViewStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__3"


    // $ANTLR start "rule__DropViewStatement__Group__3__Impl"
    // InternalMickeyLang.g:11880:1: rule__DropViewStatement__Group__3__Impl : ( ( rule__DropViewStatement__ViewAssignment_3 ) ) ;
    public final void rule__DropViewStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11884:1: ( ( ( rule__DropViewStatement__ViewAssignment_3 ) ) )
            // InternalMickeyLang.g:11885:1: ( ( rule__DropViewStatement__ViewAssignment_3 ) )
            {
            // InternalMickeyLang.g:11885:1: ( ( rule__DropViewStatement__ViewAssignment_3 ) )
            // InternalMickeyLang.g:11886:2: ( rule__DropViewStatement__ViewAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getViewAssignment_3()); 
            }
            // InternalMickeyLang.g:11887:2: ( rule__DropViewStatement__ViewAssignment_3 )
            // InternalMickeyLang.g:11887:3: rule__DropViewStatement__ViewAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__DropViewStatement__ViewAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getViewAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__Group__3__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__0"
    // InternalMickeyLang.g:11896:1: rule__CreateIndexStatement__Group__0 : rule__CreateIndexStatement__Group__0__Impl rule__CreateIndexStatement__Group__1 ;
    public final void rule__CreateIndexStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11900:1: ( rule__CreateIndexStatement__Group__0__Impl rule__CreateIndexStatement__Group__1 )
            // InternalMickeyLang.g:11901:2: rule__CreateIndexStatement__Group__0__Impl rule__CreateIndexStatement__Group__1
            {
            pushFollow(FOLLOW_98);
            rule__CreateIndexStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__0"


    // $ANTLR start "rule__CreateIndexStatement__Group__0__Impl"
    // InternalMickeyLang.g:11908:1: rule__CreateIndexStatement__Group__0__Impl : ( 'create' ) ;
    public final void rule__CreateIndexStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11912:1: ( ( 'create' ) )
            // InternalMickeyLang.g:11913:1: ( 'create' )
            {
            // InternalMickeyLang.g:11913:1: ( 'create' )
            // InternalMickeyLang.g:11914:2: 'create'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getCreateKeyword_0()); 
            }
            match(input,93,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getCreateKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__0__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__1"
    // InternalMickeyLang.g:11923:1: rule__CreateIndexStatement__Group__1 : rule__CreateIndexStatement__Group__1__Impl rule__CreateIndexStatement__Group__2 ;
    public final void rule__CreateIndexStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11927:1: ( rule__CreateIndexStatement__Group__1__Impl rule__CreateIndexStatement__Group__2 )
            // InternalMickeyLang.g:11928:2: rule__CreateIndexStatement__Group__1__Impl rule__CreateIndexStatement__Group__2
            {
            pushFollow(FOLLOW_98);
            rule__CreateIndexStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__1"


    // $ANTLR start "rule__CreateIndexStatement__Group__1__Impl"
    // InternalMickeyLang.g:11935:1: rule__CreateIndexStatement__Group__1__Impl : ( ( rule__CreateIndexStatement__UniqueAssignment_1 )? ) ;
    public final void rule__CreateIndexStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11939:1: ( ( ( rule__CreateIndexStatement__UniqueAssignment_1 )? ) )
            // InternalMickeyLang.g:11940:1: ( ( rule__CreateIndexStatement__UniqueAssignment_1 )? )
            {
            // InternalMickeyLang.g:11940:1: ( ( rule__CreateIndexStatement__UniqueAssignment_1 )? )
            // InternalMickeyLang.g:11941:2: ( rule__CreateIndexStatement__UniqueAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getUniqueAssignment_1()); 
            }
            // InternalMickeyLang.g:11942:2: ( rule__CreateIndexStatement__UniqueAssignment_1 )?
            int alt104=2;
            int LA104_0 = input.LA(1);

            if ( (LA104_0==105) ) {
                alt104=1;
            }
            switch (alt104) {
                case 1 :
                    // InternalMickeyLang.g:11942:3: rule__CreateIndexStatement__UniqueAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__CreateIndexStatement__UniqueAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getUniqueAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__1__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__2"
    // InternalMickeyLang.g:11950:1: rule__CreateIndexStatement__Group__2 : rule__CreateIndexStatement__Group__2__Impl rule__CreateIndexStatement__Group__3 ;
    public final void rule__CreateIndexStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11954:1: ( rule__CreateIndexStatement__Group__2__Impl rule__CreateIndexStatement__Group__3 )
            // InternalMickeyLang.g:11955:2: rule__CreateIndexStatement__Group__2__Impl rule__CreateIndexStatement__Group__3
            {
            pushFollow(FOLLOW_3);
            rule__CreateIndexStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__2"


    // $ANTLR start "rule__CreateIndexStatement__Group__2__Impl"
    // InternalMickeyLang.g:11962:1: rule__CreateIndexStatement__Group__2__Impl : ( 'index' ) ;
    public final void rule__CreateIndexStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11966:1: ( ( 'index' ) )
            // InternalMickeyLang.g:11967:1: ( 'index' )
            {
            // InternalMickeyLang.g:11967:1: ( 'index' )
            // InternalMickeyLang.g:11968:2: 'index'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getIndexKeyword_2()); 
            }
            match(input,103,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getIndexKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__2__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__3"
    // InternalMickeyLang.g:11977:1: rule__CreateIndexStatement__Group__3 : rule__CreateIndexStatement__Group__3__Impl rule__CreateIndexStatement__Group__4 ;
    public final void rule__CreateIndexStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11981:1: ( rule__CreateIndexStatement__Group__3__Impl rule__CreateIndexStatement__Group__4 )
            // InternalMickeyLang.g:11982:2: rule__CreateIndexStatement__Group__3__Impl rule__CreateIndexStatement__Group__4
            {
            pushFollow(FOLLOW_16);
            rule__CreateIndexStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__3"


    // $ANTLR start "rule__CreateIndexStatement__Group__3__Impl"
    // InternalMickeyLang.g:11989:1: rule__CreateIndexStatement__Group__3__Impl : ( ( rule__CreateIndexStatement__NameAssignment_3 ) ) ;
    public final void rule__CreateIndexStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:11993:1: ( ( ( rule__CreateIndexStatement__NameAssignment_3 ) ) )
            // InternalMickeyLang.g:11994:1: ( ( rule__CreateIndexStatement__NameAssignment_3 ) )
            {
            // InternalMickeyLang.g:11994:1: ( ( rule__CreateIndexStatement__NameAssignment_3 ) )
            // InternalMickeyLang.g:11995:2: ( rule__CreateIndexStatement__NameAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getNameAssignment_3()); 
            }
            // InternalMickeyLang.g:11996:2: ( rule__CreateIndexStatement__NameAssignment_3 )
            // InternalMickeyLang.g:11996:3: rule__CreateIndexStatement__NameAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__NameAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getNameAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__3__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__4"
    // InternalMickeyLang.g:12004:1: rule__CreateIndexStatement__Group__4 : rule__CreateIndexStatement__Group__4__Impl rule__CreateIndexStatement__Group__5 ;
    public final void rule__CreateIndexStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12008:1: ( rule__CreateIndexStatement__Group__4__Impl rule__CreateIndexStatement__Group__5 )
            // InternalMickeyLang.g:12009:2: rule__CreateIndexStatement__Group__4__Impl rule__CreateIndexStatement__Group__5
            {
            pushFollow(FOLLOW_3);
            rule__CreateIndexStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__4"


    // $ANTLR start "rule__CreateIndexStatement__Group__4__Impl"
    // InternalMickeyLang.g:12016:1: rule__CreateIndexStatement__Group__4__Impl : ( 'on' ) ;
    public final void rule__CreateIndexStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12020:1: ( ( 'on' ) )
            // InternalMickeyLang.g:12021:1: ( 'on' )
            {
            // InternalMickeyLang.g:12021:1: ( 'on' )
            // InternalMickeyLang.g:12022:2: 'on'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getOnKeyword_4()); 
            }
            match(input,69,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getOnKeyword_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__4__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__5"
    // InternalMickeyLang.g:12031:1: rule__CreateIndexStatement__Group__5 : rule__CreateIndexStatement__Group__5__Impl rule__CreateIndexStatement__Group__6 ;
    public final void rule__CreateIndexStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12035:1: ( rule__CreateIndexStatement__Group__5__Impl rule__CreateIndexStatement__Group__6 )
            // InternalMickeyLang.g:12036:2: rule__CreateIndexStatement__Group__5__Impl rule__CreateIndexStatement__Group__6
            {
            pushFollow(FOLLOW_6);
            rule__CreateIndexStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__5"


    // $ANTLR start "rule__CreateIndexStatement__Group__5__Impl"
    // InternalMickeyLang.g:12043:1: rule__CreateIndexStatement__Group__5__Impl : ( ( rule__CreateIndexStatement__TableAssignment_5 ) ) ;
    public final void rule__CreateIndexStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12047:1: ( ( ( rule__CreateIndexStatement__TableAssignment_5 ) ) )
            // InternalMickeyLang.g:12048:1: ( ( rule__CreateIndexStatement__TableAssignment_5 ) )
            {
            // InternalMickeyLang.g:12048:1: ( ( rule__CreateIndexStatement__TableAssignment_5 ) )
            // InternalMickeyLang.g:12049:2: ( rule__CreateIndexStatement__TableAssignment_5 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getTableAssignment_5()); 
            }
            // InternalMickeyLang.g:12050:2: ( rule__CreateIndexStatement__TableAssignment_5 )
            // InternalMickeyLang.g:12050:3: rule__CreateIndexStatement__TableAssignment_5
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__TableAssignment_5();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getTableAssignment_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__5__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__6"
    // InternalMickeyLang.g:12058:1: rule__CreateIndexStatement__Group__6 : rule__CreateIndexStatement__Group__6__Impl rule__CreateIndexStatement__Group__7 ;
    public final void rule__CreateIndexStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12062:1: ( rule__CreateIndexStatement__Group__6__Impl rule__CreateIndexStatement__Group__7 )
            // InternalMickeyLang.g:12063:2: rule__CreateIndexStatement__Group__6__Impl rule__CreateIndexStatement__Group__7
            {
            pushFollow(FOLLOW_3);
            rule__CreateIndexStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__6"


    // $ANTLR start "rule__CreateIndexStatement__Group__6__Impl"
    // InternalMickeyLang.g:12070:1: rule__CreateIndexStatement__Group__6__Impl : ( '(' ) ;
    public final void rule__CreateIndexStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12074:1: ( ( '(' ) )
            // InternalMickeyLang.g:12075:1: ( '(' )
            {
            // InternalMickeyLang.g:12075:1: ( '(' )
            // InternalMickeyLang.g:12076:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getLeftParenthesisKeyword_6()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getLeftParenthesisKeyword_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__6__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__7"
    // InternalMickeyLang.g:12085:1: rule__CreateIndexStatement__Group__7 : rule__CreateIndexStatement__Group__7__Impl rule__CreateIndexStatement__Group__8 ;
    public final void rule__CreateIndexStatement__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12089:1: ( rule__CreateIndexStatement__Group__7__Impl rule__CreateIndexStatement__Group__8 )
            // InternalMickeyLang.g:12090:2: rule__CreateIndexStatement__Group__7__Impl rule__CreateIndexStatement__Group__8
            {
            pushFollow(FOLLOW_82);
            rule__CreateIndexStatement__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__8();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__7"


    // $ANTLR start "rule__CreateIndexStatement__Group__7__Impl"
    // InternalMickeyLang.g:12097:1: rule__CreateIndexStatement__Group__7__Impl : ( ( rule__CreateIndexStatement__ColumnsAssignment_7 ) ) ;
    public final void rule__CreateIndexStatement__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12101:1: ( ( ( rule__CreateIndexStatement__ColumnsAssignment_7 ) ) )
            // InternalMickeyLang.g:12102:1: ( ( rule__CreateIndexStatement__ColumnsAssignment_7 ) )
            {
            // InternalMickeyLang.g:12102:1: ( ( rule__CreateIndexStatement__ColumnsAssignment_7 ) )
            // InternalMickeyLang.g:12103:2: ( rule__CreateIndexStatement__ColumnsAssignment_7 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getColumnsAssignment_7()); 
            }
            // InternalMickeyLang.g:12104:2: ( rule__CreateIndexStatement__ColumnsAssignment_7 )
            // InternalMickeyLang.g:12104:3: rule__CreateIndexStatement__ColumnsAssignment_7
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__ColumnsAssignment_7();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getColumnsAssignment_7()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__7__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__8"
    // InternalMickeyLang.g:12112:1: rule__CreateIndexStatement__Group__8 : rule__CreateIndexStatement__Group__8__Impl rule__CreateIndexStatement__Group__9 ;
    public final void rule__CreateIndexStatement__Group__8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12116:1: ( rule__CreateIndexStatement__Group__8__Impl rule__CreateIndexStatement__Group__9 )
            // InternalMickeyLang.g:12117:2: rule__CreateIndexStatement__Group__8__Impl rule__CreateIndexStatement__Group__9
            {
            pushFollow(FOLLOW_82);
            rule__CreateIndexStatement__Group__8__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__9();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__8"


    // $ANTLR start "rule__CreateIndexStatement__Group__8__Impl"
    // InternalMickeyLang.g:12124:1: rule__CreateIndexStatement__Group__8__Impl : ( ( rule__CreateIndexStatement__Group_8__0 )* ) ;
    public final void rule__CreateIndexStatement__Group__8__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12128:1: ( ( ( rule__CreateIndexStatement__Group_8__0 )* ) )
            // InternalMickeyLang.g:12129:1: ( ( rule__CreateIndexStatement__Group_8__0 )* )
            {
            // InternalMickeyLang.g:12129:1: ( ( rule__CreateIndexStatement__Group_8__0 )* )
            // InternalMickeyLang.g:12130:2: ( rule__CreateIndexStatement__Group_8__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getGroup_8()); 
            }
            // InternalMickeyLang.g:12131:2: ( rule__CreateIndexStatement__Group_8__0 )*
            loop105:
            do {
                int alt105=2;
                int LA105_0 = input.LA(1);

                if ( (LA105_0==40) ) {
                    alt105=1;
                }


                switch (alt105) {
            	case 1 :
            	    // InternalMickeyLang.g:12131:3: rule__CreateIndexStatement__Group_8__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__CreateIndexStatement__Group_8__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop105;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getGroup_8()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__8__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group__9"
    // InternalMickeyLang.g:12139:1: rule__CreateIndexStatement__Group__9 : rule__CreateIndexStatement__Group__9__Impl ;
    public final void rule__CreateIndexStatement__Group__9() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12143:1: ( rule__CreateIndexStatement__Group__9__Impl )
            // InternalMickeyLang.g:12144:2: rule__CreateIndexStatement__Group__9__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group__9__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__9"


    // $ANTLR start "rule__CreateIndexStatement__Group__9__Impl"
    // InternalMickeyLang.g:12150:1: rule__CreateIndexStatement__Group__9__Impl : ( ')' ) ;
    public final void rule__CreateIndexStatement__Group__9__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12154:1: ( ( ')' ) )
            // InternalMickeyLang.g:12155:1: ( ')' )
            {
            // InternalMickeyLang.g:12155:1: ( ')' )
            // InternalMickeyLang.g:12156:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getRightParenthesisKeyword_9()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getRightParenthesisKeyword_9()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group__9__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group_8__0"
    // InternalMickeyLang.g:12166:1: rule__CreateIndexStatement__Group_8__0 : rule__CreateIndexStatement__Group_8__0__Impl rule__CreateIndexStatement__Group_8__1 ;
    public final void rule__CreateIndexStatement__Group_8__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12170:1: ( rule__CreateIndexStatement__Group_8__0__Impl rule__CreateIndexStatement__Group_8__1 )
            // InternalMickeyLang.g:12171:2: rule__CreateIndexStatement__Group_8__0__Impl rule__CreateIndexStatement__Group_8__1
            {
            pushFollow(FOLLOW_3);
            rule__CreateIndexStatement__Group_8__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group_8__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group_8__0"


    // $ANTLR start "rule__CreateIndexStatement__Group_8__0__Impl"
    // InternalMickeyLang.g:12178:1: rule__CreateIndexStatement__Group_8__0__Impl : ( ',' ) ;
    public final void rule__CreateIndexStatement__Group_8__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12182:1: ( ( ',' ) )
            // InternalMickeyLang.g:12183:1: ( ',' )
            {
            // InternalMickeyLang.g:12183:1: ( ',' )
            // InternalMickeyLang.g:12184:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getCommaKeyword_8_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getCommaKeyword_8_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group_8__0__Impl"


    // $ANTLR start "rule__CreateIndexStatement__Group_8__1"
    // InternalMickeyLang.g:12193:1: rule__CreateIndexStatement__Group_8__1 : rule__CreateIndexStatement__Group_8__1__Impl ;
    public final void rule__CreateIndexStatement__Group_8__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12197:1: ( rule__CreateIndexStatement__Group_8__1__Impl )
            // InternalMickeyLang.g:12198:2: rule__CreateIndexStatement__Group_8__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__Group_8__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group_8__1"


    // $ANTLR start "rule__CreateIndexStatement__Group_8__1__Impl"
    // InternalMickeyLang.g:12204:1: rule__CreateIndexStatement__Group_8__1__Impl : ( ( rule__CreateIndexStatement__ColumnsAssignment_8_1 ) ) ;
    public final void rule__CreateIndexStatement__Group_8__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12208:1: ( ( ( rule__CreateIndexStatement__ColumnsAssignment_8_1 ) ) )
            // InternalMickeyLang.g:12209:1: ( ( rule__CreateIndexStatement__ColumnsAssignment_8_1 ) )
            {
            // InternalMickeyLang.g:12209:1: ( ( rule__CreateIndexStatement__ColumnsAssignment_8_1 ) )
            // InternalMickeyLang.g:12210:2: ( rule__CreateIndexStatement__ColumnsAssignment_8_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getColumnsAssignment_8_1()); 
            }
            // InternalMickeyLang.g:12211:2: ( rule__CreateIndexStatement__ColumnsAssignment_8_1 )
            // InternalMickeyLang.g:12211:3: rule__CreateIndexStatement__ColumnsAssignment_8_1
            {
            pushFollow(FOLLOW_2);
            rule__CreateIndexStatement__ColumnsAssignment_8_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getColumnsAssignment_8_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__Group_8__1__Impl"


    // $ANTLR start "rule__DropIndexStatement__Group__0"
    // InternalMickeyLang.g:12220:1: rule__DropIndexStatement__Group__0 : rule__DropIndexStatement__Group__0__Impl rule__DropIndexStatement__Group__1 ;
    public final void rule__DropIndexStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12224:1: ( rule__DropIndexStatement__Group__0__Impl rule__DropIndexStatement__Group__1 )
            // InternalMickeyLang.g:12225:2: rule__DropIndexStatement__Group__0__Impl rule__DropIndexStatement__Group__1
            {
            pushFollow(FOLLOW_99);
            rule__DropIndexStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropIndexStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__0"


    // $ANTLR start "rule__DropIndexStatement__Group__0__Impl"
    // InternalMickeyLang.g:12232:1: rule__DropIndexStatement__Group__0__Impl : ( 'drop' ) ;
    public final void rule__DropIndexStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12236:1: ( ( 'drop' ) )
            // InternalMickeyLang.g:12237:1: ( 'drop' )
            {
            // InternalMickeyLang.g:12237:1: ( 'drop' )
            // InternalMickeyLang.g:12238:2: 'drop'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getDropKeyword_0()); 
            }
            match(input,102,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getDropKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__0__Impl"


    // $ANTLR start "rule__DropIndexStatement__Group__1"
    // InternalMickeyLang.g:12247:1: rule__DropIndexStatement__Group__1 : rule__DropIndexStatement__Group__1__Impl rule__DropIndexStatement__Group__2 ;
    public final void rule__DropIndexStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12251:1: ( rule__DropIndexStatement__Group__1__Impl rule__DropIndexStatement__Group__2 )
            // InternalMickeyLang.g:12252:2: rule__DropIndexStatement__Group__1__Impl rule__DropIndexStatement__Group__2
            {
            pushFollow(FOLLOW_95);
            rule__DropIndexStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropIndexStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__1"


    // $ANTLR start "rule__DropIndexStatement__Group__1__Impl"
    // InternalMickeyLang.g:12259:1: rule__DropIndexStatement__Group__1__Impl : ( 'index' ) ;
    public final void rule__DropIndexStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12263:1: ( ( 'index' ) )
            // InternalMickeyLang.g:12264:1: ( 'index' )
            {
            // InternalMickeyLang.g:12264:1: ( 'index' )
            // InternalMickeyLang.g:12265:2: 'index'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIndexKeyword_1()); 
            }
            match(input,103,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIndexKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__1__Impl"


    // $ANTLR start "rule__DropIndexStatement__Group__2"
    // InternalMickeyLang.g:12274:1: rule__DropIndexStatement__Group__2 : rule__DropIndexStatement__Group__2__Impl rule__DropIndexStatement__Group__3 ;
    public final void rule__DropIndexStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12278:1: ( rule__DropIndexStatement__Group__2__Impl rule__DropIndexStatement__Group__3 )
            // InternalMickeyLang.g:12279:2: rule__DropIndexStatement__Group__2__Impl rule__DropIndexStatement__Group__3
            {
            pushFollow(FOLLOW_95);
            rule__DropIndexStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DropIndexStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__2"


    // $ANTLR start "rule__DropIndexStatement__Group__2__Impl"
    // InternalMickeyLang.g:12286:1: rule__DropIndexStatement__Group__2__Impl : ( ( rule__DropIndexStatement__IfExistsAssignment_2 )? ) ;
    public final void rule__DropIndexStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12290:1: ( ( ( rule__DropIndexStatement__IfExistsAssignment_2 )? ) )
            // InternalMickeyLang.g:12291:1: ( ( rule__DropIndexStatement__IfExistsAssignment_2 )? )
            {
            // InternalMickeyLang.g:12291:1: ( ( rule__DropIndexStatement__IfExistsAssignment_2 )? )
            // InternalMickeyLang.g:12292:2: ( rule__DropIndexStatement__IfExistsAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIfExistsAssignment_2()); 
            }
            // InternalMickeyLang.g:12293:2: ( rule__DropIndexStatement__IfExistsAssignment_2 )?
            int alt106=2;
            int LA106_0 = input.LA(1);

            if ( (LA106_0==137) ) {
                alt106=1;
            }
            switch (alt106) {
                case 1 :
                    // InternalMickeyLang.g:12293:3: rule__DropIndexStatement__IfExistsAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__DropIndexStatement__IfExistsAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIfExistsAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__2__Impl"


    // $ANTLR start "rule__DropIndexStatement__Group__3"
    // InternalMickeyLang.g:12301:1: rule__DropIndexStatement__Group__3 : rule__DropIndexStatement__Group__3__Impl ;
    public final void rule__DropIndexStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12305:1: ( rule__DropIndexStatement__Group__3__Impl )
            // InternalMickeyLang.g:12306:2: rule__DropIndexStatement__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DropIndexStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__3"


    // $ANTLR start "rule__DropIndexStatement__Group__3__Impl"
    // InternalMickeyLang.g:12312:1: rule__DropIndexStatement__Group__3__Impl : ( ( rule__DropIndexStatement__IndexAssignment_3 ) ) ;
    public final void rule__DropIndexStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12316:1: ( ( ( rule__DropIndexStatement__IndexAssignment_3 ) ) )
            // InternalMickeyLang.g:12317:1: ( ( rule__DropIndexStatement__IndexAssignment_3 ) )
            {
            // InternalMickeyLang.g:12317:1: ( ( rule__DropIndexStatement__IndexAssignment_3 ) )
            // InternalMickeyLang.g:12318:2: ( rule__DropIndexStatement__IndexAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIndexAssignment_3()); 
            }
            // InternalMickeyLang.g:12319:2: ( rule__DropIndexStatement__IndexAssignment_3 )
            // InternalMickeyLang.g:12319:3: rule__DropIndexStatement__IndexAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__DropIndexStatement__IndexAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIndexAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__Group__3__Impl"


    // $ANTLR start "rule__ColumnDef__Group__0"
    // InternalMickeyLang.g:12328:1: rule__ColumnDef__Group__0 : rule__ColumnDef__Group__0__Impl rule__ColumnDef__Group__1 ;
    public final void rule__ColumnDef__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12332:1: ( rule__ColumnDef__Group__0__Impl rule__ColumnDef__Group__1 )
            // InternalMickeyLang.g:12333:2: rule__ColumnDef__Group__0__Impl rule__ColumnDef__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__ColumnDef__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnDef__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__0"


    // $ANTLR start "rule__ColumnDef__Group__0__Impl"
    // InternalMickeyLang.g:12340:1: rule__ColumnDef__Group__0__Impl : ( () ) ;
    public final void rule__ColumnDef__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12344:1: ( ( () ) )
            // InternalMickeyLang.g:12345:1: ( () )
            {
            // InternalMickeyLang.g:12345:1: ( () )
            // InternalMickeyLang.g:12346:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getColumnDefAction_0()); 
            }
            // InternalMickeyLang.g:12347:2: ()
            // InternalMickeyLang.g:12347:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getColumnDefAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__0__Impl"


    // $ANTLR start "rule__ColumnDef__Group__1"
    // InternalMickeyLang.g:12355:1: rule__ColumnDef__Group__1 : rule__ColumnDef__Group__1__Impl rule__ColumnDef__Group__2 ;
    public final void rule__ColumnDef__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12359:1: ( rule__ColumnDef__Group__1__Impl rule__ColumnDef__Group__2 )
            // InternalMickeyLang.g:12360:2: rule__ColumnDef__Group__1__Impl rule__ColumnDef__Group__2
            {
            pushFollow(FOLLOW_13);
            rule__ColumnDef__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnDef__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__1"


    // $ANTLR start "rule__ColumnDef__Group__1__Impl"
    // InternalMickeyLang.g:12367:1: rule__ColumnDef__Group__1__Impl : ( ( rule__ColumnDef__NameAssignment_1 ) ) ;
    public final void rule__ColumnDef__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12371:1: ( ( ( rule__ColumnDef__NameAssignment_1 ) ) )
            // InternalMickeyLang.g:12372:1: ( ( rule__ColumnDef__NameAssignment_1 ) )
            {
            // InternalMickeyLang.g:12372:1: ( ( rule__ColumnDef__NameAssignment_1 ) )
            // InternalMickeyLang.g:12373:2: ( rule__ColumnDef__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getNameAssignment_1()); 
            }
            // InternalMickeyLang.g:12374:2: ( rule__ColumnDef__NameAssignment_1 )
            // InternalMickeyLang.g:12374:3: rule__ColumnDef__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ColumnDef__NameAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getNameAssignment_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__1__Impl"


    // $ANTLR start "rule__ColumnDef__Group__2"
    // InternalMickeyLang.g:12382:1: rule__ColumnDef__Group__2 : rule__ColumnDef__Group__2__Impl rule__ColumnDef__Group__3 ;
    public final void rule__ColumnDef__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12386:1: ( rule__ColumnDef__Group__2__Impl rule__ColumnDef__Group__3 )
            // InternalMickeyLang.g:12387:2: rule__ColumnDef__Group__2__Impl rule__ColumnDef__Group__3
            {
            pushFollow(FOLLOW_100);
            rule__ColumnDef__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnDef__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__2"


    // $ANTLR start "rule__ColumnDef__Group__2__Impl"
    // InternalMickeyLang.g:12394:1: rule__ColumnDef__Group__2__Impl : ( ( rule__ColumnDef__TypeAssignment_2 ) ) ;
    public final void rule__ColumnDef__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12398:1: ( ( ( rule__ColumnDef__TypeAssignment_2 ) ) )
            // InternalMickeyLang.g:12399:1: ( ( rule__ColumnDef__TypeAssignment_2 ) )
            {
            // InternalMickeyLang.g:12399:1: ( ( rule__ColumnDef__TypeAssignment_2 ) )
            // InternalMickeyLang.g:12400:2: ( rule__ColumnDef__TypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getTypeAssignment_2()); 
            }
            // InternalMickeyLang.g:12401:2: ( rule__ColumnDef__TypeAssignment_2 )
            // InternalMickeyLang.g:12401:3: rule__ColumnDef__TypeAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ColumnDef__TypeAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getTypeAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__2__Impl"


    // $ANTLR start "rule__ColumnDef__Group__3"
    // InternalMickeyLang.g:12409:1: rule__ColumnDef__Group__3 : rule__ColumnDef__Group__3__Impl ;
    public final void rule__ColumnDef__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12413:1: ( rule__ColumnDef__Group__3__Impl )
            // InternalMickeyLang.g:12414:2: rule__ColumnDef__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ColumnDef__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__3"


    // $ANTLR start "rule__ColumnDef__Group__3__Impl"
    // InternalMickeyLang.g:12420:1: rule__ColumnDef__Group__3__Impl : ( ( rule__ColumnDef__ConstraintsAssignment_3 )* ) ;
    public final void rule__ColumnDef__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12424:1: ( ( ( rule__ColumnDef__ConstraintsAssignment_3 )* ) )
            // InternalMickeyLang.g:12425:1: ( ( rule__ColumnDef__ConstraintsAssignment_3 )* )
            {
            // InternalMickeyLang.g:12425:1: ( ( rule__ColumnDef__ConstraintsAssignment_3 )* )
            // InternalMickeyLang.g:12426:2: ( rule__ColumnDef__ConstraintsAssignment_3 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getConstraintsAssignment_3()); 
            }
            // InternalMickeyLang.g:12427:2: ( rule__ColumnDef__ConstraintsAssignment_3 )*
            loop107:
            do {
                int alt107=2;
                int LA107_0 = input.LA(1);

                if ( (LA107_0==37||(LA107_0>=104 && LA107_0<=107)) ) {
                    alt107=1;
                }


                switch (alt107) {
            	case 1 :
            	    // InternalMickeyLang.g:12427:3: rule__ColumnDef__ConstraintsAssignment_3
            	    {
            	    pushFollow(FOLLOW_101);
            	    rule__ColumnDef__ConstraintsAssignment_3();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop107;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getConstraintsAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__Group__3__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_0__0"
    // InternalMickeyLang.g:12436:1: rule__ColumnConstraint__Group_0__0 : rule__ColumnConstraint__Group_0__0__Impl rule__ColumnConstraint__Group_0__1 ;
    public final void rule__ColumnConstraint__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12440:1: ( rule__ColumnConstraint__Group_0__0__Impl rule__ColumnConstraint__Group_0__1 )
            // InternalMickeyLang.g:12441:2: rule__ColumnConstraint__Group_0__0__Impl rule__ColumnConstraint__Group_0__1
            {
            pushFollow(FOLLOW_102);
            rule__ColumnConstraint__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__0"


    // $ANTLR start "rule__ColumnConstraint__Group_0__0__Impl"
    // InternalMickeyLang.g:12448:1: rule__ColumnConstraint__Group_0__0__Impl : ( () ) ;
    public final void rule__ColumnConstraint__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12452:1: ( ( () ) )
            // InternalMickeyLang.g:12453:1: ( () )
            {
            // InternalMickeyLang.g:12453:1: ( () )
            // InternalMickeyLang.g:12454:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getPrimaryKeyColumnConstraintAction_0_0()); 
            }
            // InternalMickeyLang.g:12455:2: ()
            // InternalMickeyLang.g:12455:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getPrimaryKeyColumnConstraintAction_0_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__0__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_0__1"
    // InternalMickeyLang.g:12463:1: rule__ColumnConstraint__Group_0__1 : rule__ColumnConstraint__Group_0__1__Impl rule__ColumnConstraint__Group_0__2 ;
    public final void rule__ColumnConstraint__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12467:1: ( rule__ColumnConstraint__Group_0__1__Impl rule__ColumnConstraint__Group_0__2 )
            // InternalMickeyLang.g:12468:2: rule__ColumnConstraint__Group_0__1__Impl rule__ColumnConstraint__Group_0__2
            {
            pushFollow(FOLLOW_103);
            rule__ColumnConstraint__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__1"


    // $ANTLR start "rule__ColumnConstraint__Group_0__1__Impl"
    // InternalMickeyLang.g:12475:1: rule__ColumnConstraint__Group_0__1__Impl : ( 'primary key' ) ;
    public final void rule__ColumnConstraint__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12479:1: ( ( 'primary key' ) )
            // InternalMickeyLang.g:12480:1: ( 'primary key' )
            {
            // InternalMickeyLang.g:12480:1: ( 'primary key' )
            // InternalMickeyLang.g:12481:2: 'primary key'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getPrimaryKeyKeyword_0_1()); 
            }
            match(input,104,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getPrimaryKeyKeyword_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__1__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_0__2"
    // InternalMickeyLang.g:12490:1: rule__ColumnConstraint__Group_0__2 : rule__ColumnConstraint__Group_0__2__Impl rule__ColumnConstraint__Group_0__3 ;
    public final void rule__ColumnConstraint__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12494:1: ( rule__ColumnConstraint__Group_0__2__Impl rule__ColumnConstraint__Group_0__3 )
            // InternalMickeyLang.g:12495:2: rule__ColumnConstraint__Group_0__2__Impl rule__ColumnConstraint__Group_0__3
            {
            pushFollow(FOLLOW_103);
            rule__ColumnConstraint__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_0__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__2"


    // $ANTLR start "rule__ColumnConstraint__Group_0__2__Impl"
    // InternalMickeyLang.g:12502:1: rule__ColumnConstraint__Group_0__2__Impl : ( ( rule__ColumnConstraint__Alternatives_0_2 )? ) ;
    public final void rule__ColumnConstraint__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12506:1: ( ( ( rule__ColumnConstraint__Alternatives_0_2 )? ) )
            // InternalMickeyLang.g:12507:1: ( ( rule__ColumnConstraint__Alternatives_0_2 )? )
            {
            // InternalMickeyLang.g:12507:1: ( ( rule__ColumnConstraint__Alternatives_0_2 )? )
            // InternalMickeyLang.g:12508:2: ( rule__ColumnConstraint__Alternatives_0_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAlternatives_0_2()); 
            }
            // InternalMickeyLang.g:12509:2: ( rule__ColumnConstraint__Alternatives_0_2 )?
            int alt108=2;
            int LA108_0 = input.LA(1);

            if ( ((LA108_0>=124 && LA108_0<=125)) ) {
                alt108=1;
            }
            switch (alt108) {
                case 1 :
                    // InternalMickeyLang.g:12509:3: rule__ColumnConstraint__Alternatives_0_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__Alternatives_0_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAlternatives_0_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__2__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_0__3"
    // InternalMickeyLang.g:12517:1: rule__ColumnConstraint__Group_0__3 : rule__ColumnConstraint__Group_0__3__Impl ;
    public final void rule__ColumnConstraint__Group_0__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12521:1: ( rule__ColumnConstraint__Group_0__3__Impl )
            // InternalMickeyLang.g:12522:2: rule__ColumnConstraint__Group_0__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_0__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__3"


    // $ANTLR start "rule__ColumnConstraint__Group_0__3__Impl"
    // InternalMickeyLang.g:12528:1: rule__ColumnConstraint__Group_0__3__Impl : ( ( rule__ColumnConstraint__AutoincrementAssignment_0_3 )? ) ;
    public final void rule__ColumnConstraint__Group_0__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12532:1: ( ( ( rule__ColumnConstraint__AutoincrementAssignment_0_3 )? ) )
            // InternalMickeyLang.g:12533:1: ( ( rule__ColumnConstraint__AutoincrementAssignment_0_3 )? )
            {
            // InternalMickeyLang.g:12533:1: ( ( rule__ColumnConstraint__AutoincrementAssignment_0_3 )? )
            // InternalMickeyLang.g:12534:2: ( rule__ColumnConstraint__AutoincrementAssignment_0_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAutoincrementAssignment_0_3()); 
            }
            // InternalMickeyLang.g:12535:2: ( rule__ColumnConstraint__AutoincrementAssignment_0_3 )?
            int alt109=2;
            int LA109_0 = input.LA(1);

            if ( (LA109_0==138) ) {
                alt109=1;
            }
            switch (alt109) {
                case 1 :
                    // InternalMickeyLang.g:12535:3: rule__ColumnConstraint__AutoincrementAssignment_0_3
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__AutoincrementAssignment_0_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAutoincrementAssignment_0_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_0__3__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_1__0"
    // InternalMickeyLang.g:12544:1: rule__ColumnConstraint__Group_1__0 : rule__ColumnConstraint__Group_1__0__Impl rule__ColumnConstraint__Group_1__1 ;
    public final void rule__ColumnConstraint__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12548:1: ( rule__ColumnConstraint__Group_1__0__Impl rule__ColumnConstraint__Group_1__1 )
            // InternalMickeyLang.g:12549:2: rule__ColumnConstraint__Group_1__0__Impl rule__ColumnConstraint__Group_1__1
            {
            pushFollow(FOLLOW_104);
            rule__ColumnConstraint__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_1__0"


    // $ANTLR start "rule__ColumnConstraint__Group_1__0__Impl"
    // InternalMickeyLang.g:12556:1: rule__ColumnConstraint__Group_1__0__Impl : ( () ) ;
    public final void rule__ColumnConstraint__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12560:1: ( ( () ) )
            // InternalMickeyLang.g:12561:1: ( () )
            {
            // InternalMickeyLang.g:12561:1: ( () )
            // InternalMickeyLang.g:12562:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getNotNullConstraintAction_1_0()); 
            }
            // InternalMickeyLang.g:12563:2: ()
            // InternalMickeyLang.g:12563:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getNotNullConstraintAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_1__0__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_1__1"
    // InternalMickeyLang.g:12571:1: rule__ColumnConstraint__Group_1__1 : rule__ColumnConstraint__Group_1__1__Impl rule__ColumnConstraint__Group_1__2 ;
    public final void rule__ColumnConstraint__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12575:1: ( rule__ColumnConstraint__Group_1__1__Impl rule__ColumnConstraint__Group_1__2 )
            // InternalMickeyLang.g:12576:2: rule__ColumnConstraint__Group_1__1__Impl rule__ColumnConstraint__Group_1__2
            {
            pushFollow(FOLLOW_16);
            rule__ColumnConstraint__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_1__1"


    // $ANTLR start "rule__ColumnConstraint__Group_1__1__Impl"
    // InternalMickeyLang.g:12583:1: rule__ColumnConstraint__Group_1__1__Impl : ( 'not null' ) ;
    public final void rule__ColumnConstraint__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12587:1: ( ( 'not null' ) )
            // InternalMickeyLang.g:12588:1: ( 'not null' )
            {
            // InternalMickeyLang.g:12588:1: ( 'not null' )
            // InternalMickeyLang.g:12589:2: 'not null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getNotNullKeyword_1_1()); 
            }
            match(input,37,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getNotNullKeyword_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_1__1__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_1__2"
    // InternalMickeyLang.g:12598:1: rule__ColumnConstraint__Group_1__2 : rule__ColumnConstraint__Group_1__2__Impl ;
    public final void rule__ColumnConstraint__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12602:1: ( rule__ColumnConstraint__Group_1__2__Impl )
            // InternalMickeyLang.g:12603:2: rule__ColumnConstraint__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_1__2"


    // $ANTLR start "rule__ColumnConstraint__Group_1__2__Impl"
    // InternalMickeyLang.g:12609:1: rule__ColumnConstraint__Group_1__2__Impl : ( ( rule__ColumnConstraint__ConflictClauseAssignment_1_2 )? ) ;
    public final void rule__ColumnConstraint__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12613:1: ( ( ( rule__ColumnConstraint__ConflictClauseAssignment_1_2 )? ) )
            // InternalMickeyLang.g:12614:1: ( ( rule__ColumnConstraint__ConflictClauseAssignment_1_2 )? )
            {
            // InternalMickeyLang.g:12614:1: ( ( rule__ColumnConstraint__ConflictClauseAssignment_1_2 )? )
            // InternalMickeyLang.g:12615:2: ( rule__ColumnConstraint__ConflictClauseAssignment_1_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getConflictClauseAssignment_1_2()); 
            }
            // InternalMickeyLang.g:12616:2: ( rule__ColumnConstraint__ConflictClauseAssignment_1_2 )?
            int alt110=2;
            int LA110_0 = input.LA(1);

            if ( (LA110_0==69) ) {
                alt110=1;
            }
            switch (alt110) {
                case 1 :
                    // InternalMickeyLang.g:12616:3: rule__ColumnConstraint__ConflictClauseAssignment_1_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__ConflictClauseAssignment_1_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getConflictClauseAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_1__2__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_2__0"
    // InternalMickeyLang.g:12625:1: rule__ColumnConstraint__Group_2__0 : rule__ColumnConstraint__Group_2__0__Impl rule__ColumnConstraint__Group_2__1 ;
    public final void rule__ColumnConstraint__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12629:1: ( rule__ColumnConstraint__Group_2__0__Impl rule__ColumnConstraint__Group_2__1 )
            // InternalMickeyLang.g:12630:2: rule__ColumnConstraint__Group_2__0__Impl rule__ColumnConstraint__Group_2__1
            {
            pushFollow(FOLLOW_105);
            rule__ColumnConstraint__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_2__0"


    // $ANTLR start "rule__ColumnConstraint__Group_2__0__Impl"
    // InternalMickeyLang.g:12637:1: rule__ColumnConstraint__Group_2__0__Impl : ( () ) ;
    public final void rule__ColumnConstraint__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12641:1: ( ( () ) )
            // InternalMickeyLang.g:12642:1: ( () )
            {
            // InternalMickeyLang.g:12642:1: ( () )
            // InternalMickeyLang.g:12643:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getUniqueConstraintAction_2_0()); 
            }
            // InternalMickeyLang.g:12644:2: ()
            // InternalMickeyLang.g:12644:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getUniqueConstraintAction_2_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_2__0__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_2__1"
    // InternalMickeyLang.g:12652:1: rule__ColumnConstraint__Group_2__1 : rule__ColumnConstraint__Group_2__1__Impl rule__ColumnConstraint__Group_2__2 ;
    public final void rule__ColumnConstraint__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12656:1: ( rule__ColumnConstraint__Group_2__1__Impl rule__ColumnConstraint__Group_2__2 )
            // InternalMickeyLang.g:12657:2: rule__ColumnConstraint__Group_2__1__Impl rule__ColumnConstraint__Group_2__2
            {
            pushFollow(FOLLOW_16);
            rule__ColumnConstraint__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_2__1"


    // $ANTLR start "rule__ColumnConstraint__Group_2__1__Impl"
    // InternalMickeyLang.g:12664:1: rule__ColumnConstraint__Group_2__1__Impl : ( 'unique' ) ;
    public final void rule__ColumnConstraint__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12668:1: ( ( 'unique' ) )
            // InternalMickeyLang.g:12669:1: ( 'unique' )
            {
            // InternalMickeyLang.g:12669:1: ( 'unique' )
            // InternalMickeyLang.g:12670:2: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getUniqueKeyword_2_1()); 
            }
            match(input,105,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getUniqueKeyword_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_2__1__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_2__2"
    // InternalMickeyLang.g:12679:1: rule__ColumnConstraint__Group_2__2 : rule__ColumnConstraint__Group_2__2__Impl ;
    public final void rule__ColumnConstraint__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12683:1: ( rule__ColumnConstraint__Group_2__2__Impl )
            // InternalMickeyLang.g:12684:2: rule__ColumnConstraint__Group_2__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_2__2"


    // $ANTLR start "rule__ColumnConstraint__Group_2__2__Impl"
    // InternalMickeyLang.g:12690:1: rule__ColumnConstraint__Group_2__2__Impl : ( ( rule__ColumnConstraint__ConflictClauseAssignment_2_2 )? ) ;
    public final void rule__ColumnConstraint__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12694:1: ( ( ( rule__ColumnConstraint__ConflictClauseAssignment_2_2 )? ) )
            // InternalMickeyLang.g:12695:1: ( ( rule__ColumnConstraint__ConflictClauseAssignment_2_2 )? )
            {
            // InternalMickeyLang.g:12695:1: ( ( rule__ColumnConstraint__ConflictClauseAssignment_2_2 )? )
            // InternalMickeyLang.g:12696:2: ( rule__ColumnConstraint__ConflictClauseAssignment_2_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getConflictClauseAssignment_2_2()); 
            }
            // InternalMickeyLang.g:12697:2: ( rule__ColumnConstraint__ConflictClauseAssignment_2_2 )?
            int alt111=2;
            int LA111_0 = input.LA(1);

            if ( (LA111_0==69) ) {
                alt111=1;
            }
            switch (alt111) {
                case 1 :
                    // InternalMickeyLang.g:12697:3: rule__ColumnConstraint__ConflictClauseAssignment_2_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__ColumnConstraint__ConflictClauseAssignment_2_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getConflictClauseAssignment_2_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_2__2__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_3__0"
    // InternalMickeyLang.g:12706:1: rule__ColumnConstraint__Group_3__0 : rule__ColumnConstraint__Group_3__0__Impl rule__ColumnConstraint__Group_3__1 ;
    public final void rule__ColumnConstraint__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12710:1: ( rule__ColumnConstraint__Group_3__0__Impl rule__ColumnConstraint__Group_3__1 )
            // InternalMickeyLang.g:12711:2: rule__ColumnConstraint__Group_3__0__Impl rule__ColumnConstraint__Group_3__1
            {
            pushFollow(FOLLOW_106);
            rule__ColumnConstraint__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_3__0"


    // $ANTLR start "rule__ColumnConstraint__Group_3__0__Impl"
    // InternalMickeyLang.g:12718:1: rule__ColumnConstraint__Group_3__0__Impl : ( () ) ;
    public final void rule__ColumnConstraint__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12722:1: ( ( () ) )
            // InternalMickeyLang.g:12723:1: ( () )
            {
            // InternalMickeyLang.g:12723:1: ( () )
            // InternalMickeyLang.g:12724:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getDefaultConstraintAction_3_0()); 
            }
            // InternalMickeyLang.g:12725:2: ()
            // InternalMickeyLang.g:12725:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getDefaultConstraintAction_3_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_3__0__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_3__1"
    // InternalMickeyLang.g:12733:1: rule__ColumnConstraint__Group_3__1 : rule__ColumnConstraint__Group_3__1__Impl rule__ColumnConstraint__Group_3__2 ;
    public final void rule__ColumnConstraint__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12737:1: ( rule__ColumnConstraint__Group_3__1__Impl rule__ColumnConstraint__Group_3__2 )
            // InternalMickeyLang.g:12738:2: rule__ColumnConstraint__Group_3__1__Impl rule__ColumnConstraint__Group_3__2
            {
            pushFollow(FOLLOW_107);
            rule__ColumnConstraint__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_3__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_3__1"


    // $ANTLR start "rule__ColumnConstraint__Group_3__1__Impl"
    // InternalMickeyLang.g:12745:1: rule__ColumnConstraint__Group_3__1__Impl : ( 'default' ) ;
    public final void rule__ColumnConstraint__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12749:1: ( ( 'default' ) )
            // InternalMickeyLang.g:12750:1: ( 'default' )
            {
            // InternalMickeyLang.g:12750:1: ( 'default' )
            // InternalMickeyLang.g:12751:2: 'default'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getDefaultKeyword_3_1()); 
            }
            match(input,106,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getDefaultKeyword_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_3__1__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_3__2"
    // InternalMickeyLang.g:12760:1: rule__ColumnConstraint__Group_3__2 : rule__ColumnConstraint__Group_3__2__Impl ;
    public final void rule__ColumnConstraint__Group_3__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12764:1: ( rule__ColumnConstraint__Group_3__2__Impl )
            // InternalMickeyLang.g:12765:2: rule__ColumnConstraint__Group_3__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_3__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_3__2"


    // $ANTLR start "rule__ColumnConstraint__Group_3__2__Impl"
    // InternalMickeyLang.g:12771:1: rule__ColumnConstraint__Group_3__2__Impl : ( ( rule__ColumnConstraint__DefaultValueAssignment_3_2 ) ) ;
    public final void rule__ColumnConstraint__Group_3__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12775:1: ( ( ( rule__ColumnConstraint__DefaultValueAssignment_3_2 ) ) )
            // InternalMickeyLang.g:12776:1: ( ( rule__ColumnConstraint__DefaultValueAssignment_3_2 ) )
            {
            // InternalMickeyLang.g:12776:1: ( ( rule__ColumnConstraint__DefaultValueAssignment_3_2 ) )
            // InternalMickeyLang.g:12777:2: ( rule__ColumnConstraint__DefaultValueAssignment_3_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getDefaultValueAssignment_3_2()); 
            }
            // InternalMickeyLang.g:12778:2: ( rule__ColumnConstraint__DefaultValueAssignment_3_2 )
            // InternalMickeyLang.g:12778:3: rule__ColumnConstraint__DefaultValueAssignment_3_2
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__DefaultValueAssignment_3_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getDefaultValueAssignment_3_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_3__2__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_4__0"
    // InternalMickeyLang.g:12787:1: rule__ColumnConstraint__Group_4__0 : rule__ColumnConstraint__Group_4__0__Impl rule__ColumnConstraint__Group_4__1 ;
    public final void rule__ColumnConstraint__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12791:1: ( rule__ColumnConstraint__Group_4__0__Impl rule__ColumnConstraint__Group_4__1 )
            // InternalMickeyLang.g:12792:2: rule__ColumnConstraint__Group_4__0__Impl rule__ColumnConstraint__Group_4__1
            {
            pushFollow(FOLLOW_100);
            rule__ColumnConstraint__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__0"


    // $ANTLR start "rule__ColumnConstraint__Group_4__0__Impl"
    // InternalMickeyLang.g:12799:1: rule__ColumnConstraint__Group_4__0__Impl : ( () ) ;
    public final void rule__ColumnConstraint__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12803:1: ( ( () ) )
            // InternalMickeyLang.g:12804:1: ( () )
            {
            // InternalMickeyLang.g:12804:1: ( () )
            // InternalMickeyLang.g:12805:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getCheckConstraintAction_4_0()); 
            }
            // InternalMickeyLang.g:12806:2: ()
            // InternalMickeyLang.g:12806:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getCheckConstraintAction_4_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__0__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_4__1"
    // InternalMickeyLang.g:12814:1: rule__ColumnConstraint__Group_4__1 : rule__ColumnConstraint__Group_4__1__Impl rule__ColumnConstraint__Group_4__2 ;
    public final void rule__ColumnConstraint__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12818:1: ( rule__ColumnConstraint__Group_4__1__Impl rule__ColumnConstraint__Group_4__2 )
            // InternalMickeyLang.g:12819:2: rule__ColumnConstraint__Group_4__1__Impl rule__ColumnConstraint__Group_4__2
            {
            pushFollow(FOLLOW_6);
            rule__ColumnConstraint__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_4__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__1"


    // $ANTLR start "rule__ColumnConstraint__Group_4__1__Impl"
    // InternalMickeyLang.g:12826:1: rule__ColumnConstraint__Group_4__1__Impl : ( 'check' ) ;
    public final void rule__ColumnConstraint__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12830:1: ( ( 'check' ) )
            // InternalMickeyLang.g:12831:1: ( 'check' )
            {
            // InternalMickeyLang.g:12831:1: ( 'check' )
            // InternalMickeyLang.g:12832:2: 'check'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getCheckKeyword_4_1()); 
            }
            match(input,107,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getCheckKeyword_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__1__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_4__2"
    // InternalMickeyLang.g:12841:1: rule__ColumnConstraint__Group_4__2 : rule__ColumnConstraint__Group_4__2__Impl rule__ColumnConstraint__Group_4__3 ;
    public final void rule__ColumnConstraint__Group_4__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12845:1: ( rule__ColumnConstraint__Group_4__2__Impl rule__ColumnConstraint__Group_4__3 )
            // InternalMickeyLang.g:12846:2: rule__ColumnConstraint__Group_4__2__Impl rule__ColumnConstraint__Group_4__3
            {
            pushFollow(FOLLOW_30);
            rule__ColumnConstraint__Group_4__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_4__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__2"


    // $ANTLR start "rule__ColumnConstraint__Group_4__2__Impl"
    // InternalMickeyLang.g:12853:1: rule__ColumnConstraint__Group_4__2__Impl : ( '(' ) ;
    public final void rule__ColumnConstraint__Group_4__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12857:1: ( ( '(' ) )
            // InternalMickeyLang.g:12858:1: ( '(' )
            {
            // InternalMickeyLang.g:12858:1: ( '(' )
            // InternalMickeyLang.g:12859:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getLeftParenthesisKeyword_4_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getLeftParenthesisKeyword_4_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__2__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_4__3"
    // InternalMickeyLang.g:12868:1: rule__ColumnConstraint__Group_4__3 : rule__ColumnConstraint__Group_4__3__Impl rule__ColumnConstraint__Group_4__4 ;
    public final void rule__ColumnConstraint__Group_4__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12872:1: ( rule__ColumnConstraint__Group_4__3__Impl rule__ColumnConstraint__Group_4__4 )
            // InternalMickeyLang.g:12873:2: rule__ColumnConstraint__Group_4__3__Impl rule__ColumnConstraint__Group_4__4
            {
            pushFollow(FOLLOW_52);
            rule__ColumnConstraint__Group_4__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_4__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__3"


    // $ANTLR start "rule__ColumnConstraint__Group_4__3__Impl"
    // InternalMickeyLang.g:12880:1: rule__ColumnConstraint__Group_4__3__Impl : ( ( rule__ColumnConstraint__ExpressionAssignment_4_3 ) ) ;
    public final void rule__ColumnConstraint__Group_4__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12884:1: ( ( ( rule__ColumnConstraint__ExpressionAssignment_4_3 ) ) )
            // InternalMickeyLang.g:12885:1: ( ( rule__ColumnConstraint__ExpressionAssignment_4_3 ) )
            {
            // InternalMickeyLang.g:12885:1: ( ( rule__ColumnConstraint__ExpressionAssignment_4_3 ) )
            // InternalMickeyLang.g:12886:2: ( rule__ColumnConstraint__ExpressionAssignment_4_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getExpressionAssignment_4_3()); 
            }
            // InternalMickeyLang.g:12887:2: ( rule__ColumnConstraint__ExpressionAssignment_4_3 )
            // InternalMickeyLang.g:12887:3: rule__ColumnConstraint__ExpressionAssignment_4_3
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__ExpressionAssignment_4_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getExpressionAssignment_4_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__3__Impl"


    // $ANTLR start "rule__ColumnConstraint__Group_4__4"
    // InternalMickeyLang.g:12895:1: rule__ColumnConstraint__Group_4__4 : rule__ColumnConstraint__Group_4__4__Impl ;
    public final void rule__ColumnConstraint__Group_4__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12899:1: ( rule__ColumnConstraint__Group_4__4__Impl )
            // InternalMickeyLang.g:12900:2: rule__ColumnConstraint__Group_4__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ColumnConstraint__Group_4__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__4"


    // $ANTLR start "rule__ColumnConstraint__Group_4__4__Impl"
    // InternalMickeyLang.g:12906:1: rule__ColumnConstraint__Group_4__4__Impl : ( ')' ) ;
    public final void rule__ColumnConstraint__Group_4__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12910:1: ( ( ')' ) )
            // InternalMickeyLang.g:12911:1: ( ')' )
            {
            // InternalMickeyLang.g:12911:1: ( ')' )
            // InternalMickeyLang.g:12912:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getRightParenthesisKeyword_4_4()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getRightParenthesisKeyword_4_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__Group_4__4__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__0"
    // InternalMickeyLang.g:12922:1: rule__UniqueTableConstraint__Group__0 : rule__UniqueTableConstraint__Group__0__Impl rule__UniqueTableConstraint__Group__1 ;
    public final void rule__UniqueTableConstraint__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12926:1: ( rule__UniqueTableConstraint__Group__0__Impl rule__UniqueTableConstraint__Group__1 )
            // InternalMickeyLang.g:12927:2: rule__UniqueTableConstraint__Group__0__Impl rule__UniqueTableConstraint__Group__1
            {
            pushFollow(FOLLOW_108);
            rule__UniqueTableConstraint__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__0"


    // $ANTLR start "rule__UniqueTableConstraint__Group__0__Impl"
    // InternalMickeyLang.g:12934:1: rule__UniqueTableConstraint__Group__0__Impl : ( ( rule__UniqueTableConstraint__Group_0__0 )? ) ;
    public final void rule__UniqueTableConstraint__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12938:1: ( ( ( rule__UniqueTableConstraint__Group_0__0 )? ) )
            // InternalMickeyLang.g:12939:1: ( ( rule__UniqueTableConstraint__Group_0__0 )? )
            {
            // InternalMickeyLang.g:12939:1: ( ( rule__UniqueTableConstraint__Group_0__0 )? )
            // InternalMickeyLang.g:12940:2: ( rule__UniqueTableConstraint__Group_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getGroup_0()); 
            }
            // InternalMickeyLang.g:12941:2: ( rule__UniqueTableConstraint__Group_0__0 )?
            int alt112=2;
            int LA112_0 = input.LA(1);

            if ( (LA112_0==108) ) {
                alt112=1;
            }
            switch (alt112) {
                case 1 :
                    // InternalMickeyLang.g:12941:3: rule__UniqueTableConstraint__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__UniqueTableConstraint__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getGroup_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__0__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__1"
    // InternalMickeyLang.g:12949:1: rule__UniqueTableConstraint__Group__1 : rule__UniqueTableConstraint__Group__1__Impl rule__UniqueTableConstraint__Group__2 ;
    public final void rule__UniqueTableConstraint__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12953:1: ( rule__UniqueTableConstraint__Group__1__Impl rule__UniqueTableConstraint__Group__2 )
            // InternalMickeyLang.g:12954:2: rule__UniqueTableConstraint__Group__1__Impl rule__UniqueTableConstraint__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__UniqueTableConstraint__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__1"


    // $ANTLR start "rule__UniqueTableConstraint__Group__1__Impl"
    // InternalMickeyLang.g:12961:1: rule__UniqueTableConstraint__Group__1__Impl : ( 'unique' ) ;
    public final void rule__UniqueTableConstraint__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12965:1: ( ( 'unique' ) )
            // InternalMickeyLang.g:12966:1: ( 'unique' )
            {
            // InternalMickeyLang.g:12966:1: ( 'unique' )
            // InternalMickeyLang.g:12967:2: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getUniqueKeyword_1()); 
            }
            match(input,105,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getUniqueKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__1__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__2"
    // InternalMickeyLang.g:12976:1: rule__UniqueTableConstraint__Group__2 : rule__UniqueTableConstraint__Group__2__Impl rule__UniqueTableConstraint__Group__3 ;
    public final void rule__UniqueTableConstraint__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12980:1: ( rule__UniqueTableConstraint__Group__2__Impl rule__UniqueTableConstraint__Group__3 )
            // InternalMickeyLang.g:12981:2: rule__UniqueTableConstraint__Group__2__Impl rule__UniqueTableConstraint__Group__3
            {
            pushFollow(FOLLOW_3);
            rule__UniqueTableConstraint__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__2"


    // $ANTLR start "rule__UniqueTableConstraint__Group__2__Impl"
    // InternalMickeyLang.g:12988:1: rule__UniqueTableConstraint__Group__2__Impl : ( '(' ) ;
    public final void rule__UniqueTableConstraint__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:12992:1: ( ( '(' ) )
            // InternalMickeyLang.g:12993:1: ( '(' )
            {
            // InternalMickeyLang.g:12993:1: ( '(' )
            // InternalMickeyLang.g:12994:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getLeftParenthesisKeyword_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getLeftParenthesisKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__2__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__3"
    // InternalMickeyLang.g:13003:1: rule__UniqueTableConstraint__Group__3 : rule__UniqueTableConstraint__Group__3__Impl rule__UniqueTableConstraint__Group__4 ;
    public final void rule__UniqueTableConstraint__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13007:1: ( rule__UniqueTableConstraint__Group__3__Impl rule__UniqueTableConstraint__Group__4 )
            // InternalMickeyLang.g:13008:2: rule__UniqueTableConstraint__Group__3__Impl rule__UniqueTableConstraint__Group__4
            {
            pushFollow(FOLLOW_82);
            rule__UniqueTableConstraint__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__3"


    // $ANTLR start "rule__UniqueTableConstraint__Group__3__Impl"
    // InternalMickeyLang.g:13015:1: rule__UniqueTableConstraint__Group__3__Impl : ( ( rule__UniqueTableConstraint__ColumnsAssignment_3 ) ) ;
    public final void rule__UniqueTableConstraint__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13019:1: ( ( ( rule__UniqueTableConstraint__ColumnsAssignment_3 ) ) )
            // InternalMickeyLang.g:13020:1: ( ( rule__UniqueTableConstraint__ColumnsAssignment_3 ) )
            {
            // InternalMickeyLang.g:13020:1: ( ( rule__UniqueTableConstraint__ColumnsAssignment_3 ) )
            // InternalMickeyLang.g:13021:2: ( rule__UniqueTableConstraint__ColumnsAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getColumnsAssignment_3()); 
            }
            // InternalMickeyLang.g:13022:2: ( rule__UniqueTableConstraint__ColumnsAssignment_3 )
            // InternalMickeyLang.g:13022:3: rule__UniqueTableConstraint__ColumnsAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__ColumnsAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getColumnsAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__3__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__4"
    // InternalMickeyLang.g:13030:1: rule__UniqueTableConstraint__Group__4 : rule__UniqueTableConstraint__Group__4__Impl rule__UniqueTableConstraint__Group__5 ;
    public final void rule__UniqueTableConstraint__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13034:1: ( rule__UniqueTableConstraint__Group__4__Impl rule__UniqueTableConstraint__Group__5 )
            // InternalMickeyLang.g:13035:2: rule__UniqueTableConstraint__Group__4__Impl rule__UniqueTableConstraint__Group__5
            {
            pushFollow(FOLLOW_82);
            rule__UniqueTableConstraint__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__4"


    // $ANTLR start "rule__UniqueTableConstraint__Group__4__Impl"
    // InternalMickeyLang.g:13042:1: rule__UniqueTableConstraint__Group__4__Impl : ( ( rule__UniqueTableConstraint__Group_4__0 )* ) ;
    public final void rule__UniqueTableConstraint__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13046:1: ( ( ( rule__UniqueTableConstraint__Group_4__0 )* ) )
            // InternalMickeyLang.g:13047:1: ( ( rule__UniqueTableConstraint__Group_4__0 )* )
            {
            // InternalMickeyLang.g:13047:1: ( ( rule__UniqueTableConstraint__Group_4__0 )* )
            // InternalMickeyLang.g:13048:2: ( rule__UniqueTableConstraint__Group_4__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getGroup_4()); 
            }
            // InternalMickeyLang.g:13049:2: ( rule__UniqueTableConstraint__Group_4__0 )*
            loop113:
            do {
                int alt113=2;
                int LA113_0 = input.LA(1);

                if ( (LA113_0==40) ) {
                    alt113=1;
                }


                switch (alt113) {
            	case 1 :
            	    // InternalMickeyLang.g:13049:3: rule__UniqueTableConstraint__Group_4__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__UniqueTableConstraint__Group_4__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop113;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getGroup_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__4__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__5"
    // InternalMickeyLang.g:13057:1: rule__UniqueTableConstraint__Group__5 : rule__UniqueTableConstraint__Group__5__Impl rule__UniqueTableConstraint__Group__6 ;
    public final void rule__UniqueTableConstraint__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13061:1: ( rule__UniqueTableConstraint__Group__5__Impl rule__UniqueTableConstraint__Group__6 )
            // InternalMickeyLang.g:13062:2: rule__UniqueTableConstraint__Group__5__Impl rule__UniqueTableConstraint__Group__6
            {
            pushFollow(FOLLOW_16);
            rule__UniqueTableConstraint__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__5"


    // $ANTLR start "rule__UniqueTableConstraint__Group__5__Impl"
    // InternalMickeyLang.g:13069:1: rule__UniqueTableConstraint__Group__5__Impl : ( ')' ) ;
    public final void rule__UniqueTableConstraint__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13073:1: ( ( ')' ) )
            // InternalMickeyLang.g:13074:1: ( ')' )
            {
            // InternalMickeyLang.g:13074:1: ( ')' )
            // InternalMickeyLang.g:13075:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getRightParenthesisKeyword_5()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getRightParenthesisKeyword_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__5__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group__6"
    // InternalMickeyLang.g:13084:1: rule__UniqueTableConstraint__Group__6 : rule__UniqueTableConstraint__Group__6__Impl ;
    public final void rule__UniqueTableConstraint__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13088:1: ( rule__UniqueTableConstraint__Group__6__Impl )
            // InternalMickeyLang.g:13089:2: rule__UniqueTableConstraint__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__6"


    // $ANTLR start "rule__UniqueTableConstraint__Group__6__Impl"
    // InternalMickeyLang.g:13095:1: rule__UniqueTableConstraint__Group__6__Impl : ( ( rule__UniqueTableConstraint__ConflictClauseAssignment_6 ) ) ;
    public final void rule__UniqueTableConstraint__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13099:1: ( ( ( rule__UniqueTableConstraint__ConflictClauseAssignment_6 ) ) )
            // InternalMickeyLang.g:13100:1: ( ( rule__UniqueTableConstraint__ConflictClauseAssignment_6 ) )
            {
            // InternalMickeyLang.g:13100:1: ( ( rule__UniqueTableConstraint__ConflictClauseAssignment_6 ) )
            // InternalMickeyLang.g:13101:2: ( rule__UniqueTableConstraint__ConflictClauseAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getConflictClauseAssignment_6()); 
            }
            // InternalMickeyLang.g:13102:2: ( rule__UniqueTableConstraint__ConflictClauseAssignment_6 )
            // InternalMickeyLang.g:13102:3: rule__UniqueTableConstraint__ConflictClauseAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__ConflictClauseAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getConflictClauseAssignment_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group__6__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group_0__0"
    // InternalMickeyLang.g:13111:1: rule__UniqueTableConstraint__Group_0__0 : rule__UniqueTableConstraint__Group_0__0__Impl rule__UniqueTableConstraint__Group_0__1 ;
    public final void rule__UniqueTableConstraint__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13115:1: ( rule__UniqueTableConstraint__Group_0__0__Impl rule__UniqueTableConstraint__Group_0__1 )
            // InternalMickeyLang.g:13116:2: rule__UniqueTableConstraint__Group_0__0__Impl rule__UniqueTableConstraint__Group_0__1
            {
            pushFollow(FOLLOW_3);
            rule__UniqueTableConstraint__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_0__0"


    // $ANTLR start "rule__UniqueTableConstraint__Group_0__0__Impl"
    // InternalMickeyLang.g:13123:1: rule__UniqueTableConstraint__Group_0__0__Impl : ( 'constraint' ) ;
    public final void rule__UniqueTableConstraint__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13127:1: ( ( 'constraint' ) )
            // InternalMickeyLang.g:13128:1: ( 'constraint' )
            {
            // InternalMickeyLang.g:13128:1: ( 'constraint' )
            // InternalMickeyLang.g:13129:2: 'constraint'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getConstraintKeyword_0_0()); 
            }
            match(input,108,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getConstraintKeyword_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_0__0__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group_0__1"
    // InternalMickeyLang.g:13138:1: rule__UniqueTableConstraint__Group_0__1 : rule__UniqueTableConstraint__Group_0__1__Impl ;
    public final void rule__UniqueTableConstraint__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13142:1: ( rule__UniqueTableConstraint__Group_0__1__Impl )
            // InternalMickeyLang.g:13143:2: rule__UniqueTableConstraint__Group_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_0__1"


    // $ANTLR start "rule__UniqueTableConstraint__Group_0__1__Impl"
    // InternalMickeyLang.g:13149:1: rule__UniqueTableConstraint__Group_0__1__Impl : ( ( rule__UniqueTableConstraint__NameAssignment_0_1 ) ) ;
    public final void rule__UniqueTableConstraint__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13153:1: ( ( ( rule__UniqueTableConstraint__NameAssignment_0_1 ) ) )
            // InternalMickeyLang.g:13154:1: ( ( rule__UniqueTableConstraint__NameAssignment_0_1 ) )
            {
            // InternalMickeyLang.g:13154:1: ( ( rule__UniqueTableConstraint__NameAssignment_0_1 ) )
            // InternalMickeyLang.g:13155:2: ( rule__UniqueTableConstraint__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getNameAssignment_0_1()); 
            }
            // InternalMickeyLang.g:13156:2: ( rule__UniqueTableConstraint__NameAssignment_0_1 )
            // InternalMickeyLang.g:13156:3: rule__UniqueTableConstraint__NameAssignment_0_1
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getNameAssignment_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_0__1__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group_4__0"
    // InternalMickeyLang.g:13165:1: rule__UniqueTableConstraint__Group_4__0 : rule__UniqueTableConstraint__Group_4__0__Impl rule__UniqueTableConstraint__Group_4__1 ;
    public final void rule__UniqueTableConstraint__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13169:1: ( rule__UniqueTableConstraint__Group_4__0__Impl rule__UniqueTableConstraint__Group_4__1 )
            // InternalMickeyLang.g:13170:2: rule__UniqueTableConstraint__Group_4__0__Impl rule__UniqueTableConstraint__Group_4__1
            {
            pushFollow(FOLLOW_3);
            rule__UniqueTableConstraint__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_4__0"


    // $ANTLR start "rule__UniqueTableConstraint__Group_4__0__Impl"
    // InternalMickeyLang.g:13177:1: rule__UniqueTableConstraint__Group_4__0__Impl : ( ',' ) ;
    public final void rule__UniqueTableConstraint__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13181:1: ( ( ',' ) )
            // InternalMickeyLang.g:13182:1: ( ',' )
            {
            // InternalMickeyLang.g:13182:1: ( ',' )
            // InternalMickeyLang.g:13183:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getCommaKeyword_4_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getCommaKeyword_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_4__0__Impl"


    // $ANTLR start "rule__UniqueTableConstraint__Group_4__1"
    // InternalMickeyLang.g:13192:1: rule__UniqueTableConstraint__Group_4__1 : rule__UniqueTableConstraint__Group_4__1__Impl ;
    public final void rule__UniqueTableConstraint__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13196:1: ( rule__UniqueTableConstraint__Group_4__1__Impl )
            // InternalMickeyLang.g:13197:2: rule__UniqueTableConstraint__Group_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_4__1"


    // $ANTLR start "rule__UniqueTableConstraint__Group_4__1__Impl"
    // InternalMickeyLang.g:13203:1: rule__UniqueTableConstraint__Group_4__1__Impl : ( ( rule__UniqueTableConstraint__ColumnsAssignment_4_1 ) ) ;
    public final void rule__UniqueTableConstraint__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13207:1: ( ( ( rule__UniqueTableConstraint__ColumnsAssignment_4_1 ) ) )
            // InternalMickeyLang.g:13208:1: ( ( rule__UniqueTableConstraint__ColumnsAssignment_4_1 ) )
            {
            // InternalMickeyLang.g:13208:1: ( ( rule__UniqueTableConstraint__ColumnsAssignment_4_1 ) )
            // InternalMickeyLang.g:13209:2: ( rule__UniqueTableConstraint__ColumnsAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getColumnsAssignment_4_1()); 
            }
            // InternalMickeyLang.g:13210:2: ( rule__UniqueTableConstraint__ColumnsAssignment_4_1 )
            // InternalMickeyLang.g:13210:3: rule__UniqueTableConstraint__ColumnsAssignment_4_1
            {
            pushFollow(FOLLOW_2);
            rule__UniqueTableConstraint__ColumnsAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getColumnsAssignment_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__Group_4__1__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__0"
    // InternalMickeyLang.g:13219:1: rule__PrimaryConstraint__Group__0 : rule__PrimaryConstraint__Group__0__Impl rule__PrimaryConstraint__Group__1 ;
    public final void rule__PrimaryConstraint__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13223:1: ( rule__PrimaryConstraint__Group__0__Impl rule__PrimaryConstraint__Group__1 )
            // InternalMickeyLang.g:13224:2: rule__PrimaryConstraint__Group__0__Impl rule__PrimaryConstraint__Group__1
            {
            pushFollow(FOLLOW_109);
            rule__PrimaryConstraint__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__0"


    // $ANTLR start "rule__PrimaryConstraint__Group__0__Impl"
    // InternalMickeyLang.g:13231:1: rule__PrimaryConstraint__Group__0__Impl : ( ( rule__PrimaryConstraint__Group_0__0 )? ) ;
    public final void rule__PrimaryConstraint__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13235:1: ( ( ( rule__PrimaryConstraint__Group_0__0 )? ) )
            // InternalMickeyLang.g:13236:1: ( ( rule__PrimaryConstraint__Group_0__0 )? )
            {
            // InternalMickeyLang.g:13236:1: ( ( rule__PrimaryConstraint__Group_0__0 )? )
            // InternalMickeyLang.g:13237:2: ( rule__PrimaryConstraint__Group_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getGroup_0()); 
            }
            // InternalMickeyLang.g:13238:2: ( rule__PrimaryConstraint__Group_0__0 )?
            int alt114=2;
            int LA114_0 = input.LA(1);

            if ( (LA114_0==108) ) {
                alt114=1;
            }
            switch (alt114) {
                case 1 :
                    // InternalMickeyLang.g:13238:3: rule__PrimaryConstraint__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PrimaryConstraint__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getGroup_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__0__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__1"
    // InternalMickeyLang.g:13246:1: rule__PrimaryConstraint__Group__1 : rule__PrimaryConstraint__Group__1__Impl rule__PrimaryConstraint__Group__2 ;
    public final void rule__PrimaryConstraint__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13250:1: ( rule__PrimaryConstraint__Group__1__Impl rule__PrimaryConstraint__Group__2 )
            // InternalMickeyLang.g:13251:2: rule__PrimaryConstraint__Group__1__Impl rule__PrimaryConstraint__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__PrimaryConstraint__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__1"


    // $ANTLR start "rule__PrimaryConstraint__Group__1__Impl"
    // InternalMickeyLang.g:13258:1: rule__PrimaryConstraint__Group__1__Impl : ( 'primary key' ) ;
    public final void rule__PrimaryConstraint__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13262:1: ( ( 'primary key' ) )
            // InternalMickeyLang.g:13263:1: ( 'primary key' )
            {
            // InternalMickeyLang.g:13263:1: ( 'primary key' )
            // InternalMickeyLang.g:13264:2: 'primary key'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getPrimaryKeyKeyword_1()); 
            }
            match(input,104,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getPrimaryKeyKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__1__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__2"
    // InternalMickeyLang.g:13273:1: rule__PrimaryConstraint__Group__2 : rule__PrimaryConstraint__Group__2__Impl rule__PrimaryConstraint__Group__3 ;
    public final void rule__PrimaryConstraint__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13277:1: ( rule__PrimaryConstraint__Group__2__Impl rule__PrimaryConstraint__Group__3 )
            // InternalMickeyLang.g:13278:2: rule__PrimaryConstraint__Group__2__Impl rule__PrimaryConstraint__Group__3
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryConstraint__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__2"


    // $ANTLR start "rule__PrimaryConstraint__Group__2__Impl"
    // InternalMickeyLang.g:13285:1: rule__PrimaryConstraint__Group__2__Impl : ( '(' ) ;
    public final void rule__PrimaryConstraint__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13289:1: ( ( '(' ) )
            // InternalMickeyLang.g:13290:1: ( '(' )
            {
            // InternalMickeyLang.g:13290:1: ( '(' )
            // InternalMickeyLang.g:13291:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getLeftParenthesisKeyword_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getLeftParenthesisKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__2__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__3"
    // InternalMickeyLang.g:13300:1: rule__PrimaryConstraint__Group__3 : rule__PrimaryConstraint__Group__3__Impl rule__PrimaryConstraint__Group__4 ;
    public final void rule__PrimaryConstraint__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13304:1: ( rule__PrimaryConstraint__Group__3__Impl rule__PrimaryConstraint__Group__4 )
            // InternalMickeyLang.g:13305:2: rule__PrimaryConstraint__Group__3__Impl rule__PrimaryConstraint__Group__4
            {
            pushFollow(FOLLOW_82);
            rule__PrimaryConstraint__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__3"


    // $ANTLR start "rule__PrimaryConstraint__Group__3__Impl"
    // InternalMickeyLang.g:13312:1: rule__PrimaryConstraint__Group__3__Impl : ( ( rule__PrimaryConstraint__ColumnsAssignment_3 ) ) ;
    public final void rule__PrimaryConstraint__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13316:1: ( ( ( rule__PrimaryConstraint__ColumnsAssignment_3 ) ) )
            // InternalMickeyLang.g:13317:1: ( ( rule__PrimaryConstraint__ColumnsAssignment_3 ) )
            {
            // InternalMickeyLang.g:13317:1: ( ( rule__PrimaryConstraint__ColumnsAssignment_3 ) )
            // InternalMickeyLang.g:13318:2: ( rule__PrimaryConstraint__ColumnsAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getColumnsAssignment_3()); 
            }
            // InternalMickeyLang.g:13319:2: ( rule__PrimaryConstraint__ColumnsAssignment_3 )
            // InternalMickeyLang.g:13319:3: rule__PrimaryConstraint__ColumnsAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__ColumnsAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getColumnsAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__3__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__4"
    // InternalMickeyLang.g:13327:1: rule__PrimaryConstraint__Group__4 : rule__PrimaryConstraint__Group__4__Impl rule__PrimaryConstraint__Group__5 ;
    public final void rule__PrimaryConstraint__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13331:1: ( rule__PrimaryConstraint__Group__4__Impl rule__PrimaryConstraint__Group__5 )
            // InternalMickeyLang.g:13332:2: rule__PrimaryConstraint__Group__4__Impl rule__PrimaryConstraint__Group__5
            {
            pushFollow(FOLLOW_82);
            rule__PrimaryConstraint__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__4"


    // $ANTLR start "rule__PrimaryConstraint__Group__4__Impl"
    // InternalMickeyLang.g:13339:1: rule__PrimaryConstraint__Group__4__Impl : ( ( rule__PrimaryConstraint__Group_4__0 )* ) ;
    public final void rule__PrimaryConstraint__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13343:1: ( ( ( rule__PrimaryConstraint__Group_4__0 )* ) )
            // InternalMickeyLang.g:13344:1: ( ( rule__PrimaryConstraint__Group_4__0 )* )
            {
            // InternalMickeyLang.g:13344:1: ( ( rule__PrimaryConstraint__Group_4__0 )* )
            // InternalMickeyLang.g:13345:2: ( rule__PrimaryConstraint__Group_4__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getGroup_4()); 
            }
            // InternalMickeyLang.g:13346:2: ( rule__PrimaryConstraint__Group_4__0 )*
            loop115:
            do {
                int alt115=2;
                int LA115_0 = input.LA(1);

                if ( (LA115_0==40) ) {
                    alt115=1;
                }


                switch (alt115) {
            	case 1 :
            	    // InternalMickeyLang.g:13346:3: rule__PrimaryConstraint__Group_4__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__PrimaryConstraint__Group_4__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop115;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getGroup_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__4__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__5"
    // InternalMickeyLang.g:13354:1: rule__PrimaryConstraint__Group__5 : rule__PrimaryConstraint__Group__5__Impl rule__PrimaryConstraint__Group__6 ;
    public final void rule__PrimaryConstraint__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13358:1: ( rule__PrimaryConstraint__Group__5__Impl rule__PrimaryConstraint__Group__6 )
            // InternalMickeyLang.g:13359:2: rule__PrimaryConstraint__Group__5__Impl rule__PrimaryConstraint__Group__6
            {
            pushFollow(FOLLOW_16);
            rule__PrimaryConstraint__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__5"


    // $ANTLR start "rule__PrimaryConstraint__Group__5__Impl"
    // InternalMickeyLang.g:13366:1: rule__PrimaryConstraint__Group__5__Impl : ( ')' ) ;
    public final void rule__PrimaryConstraint__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13370:1: ( ( ')' ) )
            // InternalMickeyLang.g:13371:1: ( ')' )
            {
            // InternalMickeyLang.g:13371:1: ( ')' )
            // InternalMickeyLang.g:13372:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getRightParenthesisKeyword_5()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getRightParenthesisKeyword_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__5__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group__6"
    // InternalMickeyLang.g:13381:1: rule__PrimaryConstraint__Group__6 : rule__PrimaryConstraint__Group__6__Impl ;
    public final void rule__PrimaryConstraint__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13385:1: ( rule__PrimaryConstraint__Group__6__Impl )
            // InternalMickeyLang.g:13386:2: rule__PrimaryConstraint__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__6"


    // $ANTLR start "rule__PrimaryConstraint__Group__6__Impl"
    // InternalMickeyLang.g:13392:1: rule__PrimaryConstraint__Group__6__Impl : ( ( rule__PrimaryConstraint__ConflictClauseAssignment_6 ) ) ;
    public final void rule__PrimaryConstraint__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13396:1: ( ( ( rule__PrimaryConstraint__ConflictClauseAssignment_6 ) ) )
            // InternalMickeyLang.g:13397:1: ( ( rule__PrimaryConstraint__ConflictClauseAssignment_6 ) )
            {
            // InternalMickeyLang.g:13397:1: ( ( rule__PrimaryConstraint__ConflictClauseAssignment_6 ) )
            // InternalMickeyLang.g:13398:2: ( rule__PrimaryConstraint__ConflictClauseAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getConflictClauseAssignment_6()); 
            }
            // InternalMickeyLang.g:13399:2: ( rule__PrimaryConstraint__ConflictClauseAssignment_6 )
            // InternalMickeyLang.g:13399:3: rule__PrimaryConstraint__ConflictClauseAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__ConflictClauseAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getConflictClauseAssignment_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group__6__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group_0__0"
    // InternalMickeyLang.g:13408:1: rule__PrimaryConstraint__Group_0__0 : rule__PrimaryConstraint__Group_0__0__Impl rule__PrimaryConstraint__Group_0__1 ;
    public final void rule__PrimaryConstraint__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13412:1: ( rule__PrimaryConstraint__Group_0__0__Impl rule__PrimaryConstraint__Group_0__1 )
            // InternalMickeyLang.g:13413:2: rule__PrimaryConstraint__Group_0__0__Impl rule__PrimaryConstraint__Group_0__1
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryConstraint__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_0__0"


    // $ANTLR start "rule__PrimaryConstraint__Group_0__0__Impl"
    // InternalMickeyLang.g:13420:1: rule__PrimaryConstraint__Group_0__0__Impl : ( 'constraint' ) ;
    public final void rule__PrimaryConstraint__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13424:1: ( ( 'constraint' ) )
            // InternalMickeyLang.g:13425:1: ( 'constraint' )
            {
            // InternalMickeyLang.g:13425:1: ( 'constraint' )
            // InternalMickeyLang.g:13426:2: 'constraint'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getConstraintKeyword_0_0()); 
            }
            match(input,108,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getConstraintKeyword_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_0__0__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group_0__1"
    // InternalMickeyLang.g:13435:1: rule__PrimaryConstraint__Group_0__1 : rule__PrimaryConstraint__Group_0__1__Impl ;
    public final void rule__PrimaryConstraint__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13439:1: ( rule__PrimaryConstraint__Group_0__1__Impl )
            // InternalMickeyLang.g:13440:2: rule__PrimaryConstraint__Group_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_0__1"


    // $ANTLR start "rule__PrimaryConstraint__Group_0__1__Impl"
    // InternalMickeyLang.g:13446:1: rule__PrimaryConstraint__Group_0__1__Impl : ( ( rule__PrimaryConstraint__NameAssignment_0_1 ) ) ;
    public final void rule__PrimaryConstraint__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13450:1: ( ( ( rule__PrimaryConstraint__NameAssignment_0_1 ) ) )
            // InternalMickeyLang.g:13451:1: ( ( rule__PrimaryConstraint__NameAssignment_0_1 ) )
            {
            // InternalMickeyLang.g:13451:1: ( ( rule__PrimaryConstraint__NameAssignment_0_1 ) )
            // InternalMickeyLang.g:13452:2: ( rule__PrimaryConstraint__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getNameAssignment_0_1()); 
            }
            // InternalMickeyLang.g:13453:2: ( rule__PrimaryConstraint__NameAssignment_0_1 )
            // InternalMickeyLang.g:13453:3: rule__PrimaryConstraint__NameAssignment_0_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getNameAssignment_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_0__1__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group_4__0"
    // InternalMickeyLang.g:13462:1: rule__PrimaryConstraint__Group_4__0 : rule__PrimaryConstraint__Group_4__0__Impl rule__PrimaryConstraint__Group_4__1 ;
    public final void rule__PrimaryConstraint__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13466:1: ( rule__PrimaryConstraint__Group_4__0__Impl rule__PrimaryConstraint__Group_4__1 )
            // InternalMickeyLang.g:13467:2: rule__PrimaryConstraint__Group_4__0__Impl rule__PrimaryConstraint__Group_4__1
            {
            pushFollow(FOLLOW_3);
            rule__PrimaryConstraint__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_4__0"


    // $ANTLR start "rule__PrimaryConstraint__Group_4__0__Impl"
    // InternalMickeyLang.g:13474:1: rule__PrimaryConstraint__Group_4__0__Impl : ( ',' ) ;
    public final void rule__PrimaryConstraint__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13478:1: ( ( ',' ) )
            // InternalMickeyLang.g:13479:1: ( ',' )
            {
            // InternalMickeyLang.g:13479:1: ( ',' )
            // InternalMickeyLang.g:13480:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getCommaKeyword_4_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getCommaKeyword_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_4__0__Impl"


    // $ANTLR start "rule__PrimaryConstraint__Group_4__1"
    // InternalMickeyLang.g:13489:1: rule__PrimaryConstraint__Group_4__1 : rule__PrimaryConstraint__Group_4__1__Impl ;
    public final void rule__PrimaryConstraint__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13493:1: ( rule__PrimaryConstraint__Group_4__1__Impl )
            // InternalMickeyLang.g:13494:2: rule__PrimaryConstraint__Group_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_4__1"


    // $ANTLR start "rule__PrimaryConstraint__Group_4__1__Impl"
    // InternalMickeyLang.g:13500:1: rule__PrimaryConstraint__Group_4__1__Impl : ( ( rule__PrimaryConstraint__ColumnsAssignment_4_1 ) ) ;
    public final void rule__PrimaryConstraint__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13504:1: ( ( ( rule__PrimaryConstraint__ColumnsAssignment_4_1 ) ) )
            // InternalMickeyLang.g:13505:1: ( ( rule__PrimaryConstraint__ColumnsAssignment_4_1 ) )
            {
            // InternalMickeyLang.g:13505:1: ( ( rule__PrimaryConstraint__ColumnsAssignment_4_1 ) )
            // InternalMickeyLang.g:13506:2: ( rule__PrimaryConstraint__ColumnsAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getColumnsAssignment_4_1()); 
            }
            // InternalMickeyLang.g:13507:2: ( rule__PrimaryConstraint__ColumnsAssignment_4_1 )
            // InternalMickeyLang.g:13507:3: rule__PrimaryConstraint__ColumnsAssignment_4_1
            {
            pushFollow(FOLLOW_2);
            rule__PrimaryConstraint__ColumnsAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getColumnsAssignment_4_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__Group_4__1__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group__0"
    // InternalMickeyLang.g:13516:1: rule__CheckTableConstraint__Group__0 : rule__CheckTableConstraint__Group__0__Impl rule__CheckTableConstraint__Group__1 ;
    public final void rule__CheckTableConstraint__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13520:1: ( rule__CheckTableConstraint__Group__0__Impl rule__CheckTableConstraint__Group__1 )
            // InternalMickeyLang.g:13521:2: rule__CheckTableConstraint__Group__0__Impl rule__CheckTableConstraint__Group__1
            {
            pushFollow(FOLLOW_83);
            rule__CheckTableConstraint__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__0"


    // $ANTLR start "rule__CheckTableConstraint__Group__0__Impl"
    // InternalMickeyLang.g:13528:1: rule__CheckTableConstraint__Group__0__Impl : ( ( rule__CheckTableConstraint__Group_0__0 )? ) ;
    public final void rule__CheckTableConstraint__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13532:1: ( ( ( rule__CheckTableConstraint__Group_0__0 )? ) )
            // InternalMickeyLang.g:13533:1: ( ( rule__CheckTableConstraint__Group_0__0 )? )
            {
            // InternalMickeyLang.g:13533:1: ( ( rule__CheckTableConstraint__Group_0__0 )? )
            // InternalMickeyLang.g:13534:2: ( rule__CheckTableConstraint__Group_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getGroup_0()); 
            }
            // InternalMickeyLang.g:13535:2: ( rule__CheckTableConstraint__Group_0__0 )?
            int alt116=2;
            int LA116_0 = input.LA(1);

            if ( (LA116_0==108) ) {
                alt116=1;
            }
            switch (alt116) {
                case 1 :
                    // InternalMickeyLang.g:13535:3: rule__CheckTableConstraint__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CheckTableConstraint__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getGroup_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__0__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group__1"
    // InternalMickeyLang.g:13543:1: rule__CheckTableConstraint__Group__1 : rule__CheckTableConstraint__Group__1__Impl rule__CheckTableConstraint__Group__2 ;
    public final void rule__CheckTableConstraint__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13547:1: ( rule__CheckTableConstraint__Group__1__Impl rule__CheckTableConstraint__Group__2 )
            // InternalMickeyLang.g:13548:2: rule__CheckTableConstraint__Group__1__Impl rule__CheckTableConstraint__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__CheckTableConstraint__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__1"


    // $ANTLR start "rule__CheckTableConstraint__Group__1__Impl"
    // InternalMickeyLang.g:13555:1: rule__CheckTableConstraint__Group__1__Impl : ( 'check' ) ;
    public final void rule__CheckTableConstraint__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13559:1: ( ( 'check' ) )
            // InternalMickeyLang.g:13560:1: ( 'check' )
            {
            // InternalMickeyLang.g:13560:1: ( 'check' )
            // InternalMickeyLang.g:13561:2: 'check'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getCheckKeyword_1()); 
            }
            match(input,107,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getCheckKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__1__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group__2"
    // InternalMickeyLang.g:13570:1: rule__CheckTableConstraint__Group__2 : rule__CheckTableConstraint__Group__2__Impl rule__CheckTableConstraint__Group__3 ;
    public final void rule__CheckTableConstraint__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13574:1: ( rule__CheckTableConstraint__Group__2__Impl rule__CheckTableConstraint__Group__3 )
            // InternalMickeyLang.g:13575:2: rule__CheckTableConstraint__Group__2__Impl rule__CheckTableConstraint__Group__3
            {
            pushFollow(FOLLOW_30);
            rule__CheckTableConstraint__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__2"


    // $ANTLR start "rule__CheckTableConstraint__Group__2__Impl"
    // InternalMickeyLang.g:13582:1: rule__CheckTableConstraint__Group__2__Impl : ( '(' ) ;
    public final void rule__CheckTableConstraint__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13586:1: ( ( '(' ) )
            // InternalMickeyLang.g:13587:1: ( '(' )
            {
            // InternalMickeyLang.g:13587:1: ( '(' )
            // InternalMickeyLang.g:13588:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getLeftParenthesisKeyword_2()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getLeftParenthesisKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__2__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group__3"
    // InternalMickeyLang.g:13597:1: rule__CheckTableConstraint__Group__3 : rule__CheckTableConstraint__Group__3__Impl rule__CheckTableConstraint__Group__4 ;
    public final void rule__CheckTableConstraint__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13601:1: ( rule__CheckTableConstraint__Group__3__Impl rule__CheckTableConstraint__Group__4 )
            // InternalMickeyLang.g:13602:2: rule__CheckTableConstraint__Group__3__Impl rule__CheckTableConstraint__Group__4
            {
            pushFollow(FOLLOW_52);
            rule__CheckTableConstraint__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__3"


    // $ANTLR start "rule__CheckTableConstraint__Group__3__Impl"
    // InternalMickeyLang.g:13609:1: rule__CheckTableConstraint__Group__3__Impl : ( ( rule__CheckTableConstraint__ExpressionAssignment_3 ) ) ;
    public final void rule__CheckTableConstraint__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13613:1: ( ( ( rule__CheckTableConstraint__ExpressionAssignment_3 ) ) )
            // InternalMickeyLang.g:13614:1: ( ( rule__CheckTableConstraint__ExpressionAssignment_3 ) )
            {
            // InternalMickeyLang.g:13614:1: ( ( rule__CheckTableConstraint__ExpressionAssignment_3 ) )
            // InternalMickeyLang.g:13615:2: ( rule__CheckTableConstraint__ExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getExpressionAssignment_3()); 
            }
            // InternalMickeyLang.g:13616:2: ( rule__CheckTableConstraint__ExpressionAssignment_3 )
            // InternalMickeyLang.g:13616:3: rule__CheckTableConstraint__ExpressionAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__ExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getExpressionAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__3__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group__4"
    // InternalMickeyLang.g:13624:1: rule__CheckTableConstraint__Group__4 : rule__CheckTableConstraint__Group__4__Impl ;
    public final void rule__CheckTableConstraint__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13628:1: ( rule__CheckTableConstraint__Group__4__Impl )
            // InternalMickeyLang.g:13629:2: rule__CheckTableConstraint__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__4"


    // $ANTLR start "rule__CheckTableConstraint__Group__4__Impl"
    // InternalMickeyLang.g:13635:1: rule__CheckTableConstraint__Group__4__Impl : ( ')' ) ;
    public final void rule__CheckTableConstraint__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13639:1: ( ( ')' ) )
            // InternalMickeyLang.g:13640:1: ( ')' )
            {
            // InternalMickeyLang.g:13640:1: ( ')' )
            // InternalMickeyLang.g:13641:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getRightParenthesisKeyword_4()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getRightParenthesisKeyword_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group__4__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group_0__0"
    // InternalMickeyLang.g:13651:1: rule__CheckTableConstraint__Group_0__0 : rule__CheckTableConstraint__Group_0__0__Impl rule__CheckTableConstraint__Group_0__1 ;
    public final void rule__CheckTableConstraint__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13655:1: ( rule__CheckTableConstraint__Group_0__0__Impl rule__CheckTableConstraint__Group_0__1 )
            // InternalMickeyLang.g:13656:2: rule__CheckTableConstraint__Group_0__0__Impl rule__CheckTableConstraint__Group_0__1
            {
            pushFollow(FOLLOW_3);
            rule__CheckTableConstraint__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group_0__0"


    // $ANTLR start "rule__CheckTableConstraint__Group_0__0__Impl"
    // InternalMickeyLang.g:13663:1: rule__CheckTableConstraint__Group_0__0__Impl : ( 'constraint' ) ;
    public final void rule__CheckTableConstraint__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13667:1: ( ( 'constraint' ) )
            // InternalMickeyLang.g:13668:1: ( 'constraint' )
            {
            // InternalMickeyLang.g:13668:1: ( 'constraint' )
            // InternalMickeyLang.g:13669:2: 'constraint'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getConstraintKeyword_0_0()); 
            }
            match(input,108,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getConstraintKeyword_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group_0__0__Impl"


    // $ANTLR start "rule__CheckTableConstraint__Group_0__1"
    // InternalMickeyLang.g:13678:1: rule__CheckTableConstraint__Group_0__1 : rule__CheckTableConstraint__Group_0__1__Impl ;
    public final void rule__CheckTableConstraint__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13682:1: ( rule__CheckTableConstraint__Group_0__1__Impl )
            // InternalMickeyLang.g:13683:2: rule__CheckTableConstraint__Group_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group_0__1"


    // $ANTLR start "rule__CheckTableConstraint__Group_0__1__Impl"
    // InternalMickeyLang.g:13689:1: rule__CheckTableConstraint__Group_0__1__Impl : ( ( rule__CheckTableConstraint__NameAssignment_0_1 ) ) ;
    public final void rule__CheckTableConstraint__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13693:1: ( ( ( rule__CheckTableConstraint__NameAssignment_0_1 ) ) )
            // InternalMickeyLang.g:13694:1: ( ( rule__CheckTableConstraint__NameAssignment_0_1 ) )
            {
            // InternalMickeyLang.g:13694:1: ( ( rule__CheckTableConstraint__NameAssignment_0_1 ) )
            // InternalMickeyLang.g:13695:2: ( rule__CheckTableConstraint__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getNameAssignment_0_1()); 
            }
            // InternalMickeyLang.g:13696:2: ( rule__CheckTableConstraint__NameAssignment_0_1 )
            // InternalMickeyLang.g:13696:3: rule__CheckTableConstraint__NameAssignment_0_1
            {
            pushFollow(FOLLOW_2);
            rule__CheckTableConstraint__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getNameAssignment_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__Group_0__1__Impl"


    // $ANTLR start "rule__IndexedColumn__Group__0"
    // InternalMickeyLang.g:13705:1: rule__IndexedColumn__Group__0 : rule__IndexedColumn__Group__0__Impl rule__IndexedColumn__Group__1 ;
    public final void rule__IndexedColumn__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13709:1: ( rule__IndexedColumn__Group__0__Impl rule__IndexedColumn__Group__1 )
            // InternalMickeyLang.g:13710:2: rule__IndexedColumn__Group__0__Impl rule__IndexedColumn__Group__1
            {
            pushFollow(FOLLOW_110);
            rule__IndexedColumn__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group__0"


    // $ANTLR start "rule__IndexedColumn__Group__0__Impl"
    // InternalMickeyLang.g:13717:1: rule__IndexedColumn__Group__0__Impl : ( ( rule__IndexedColumn__ColumnReferenceAssignment_0 ) ) ;
    public final void rule__IndexedColumn__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13721:1: ( ( ( rule__IndexedColumn__ColumnReferenceAssignment_0 ) ) )
            // InternalMickeyLang.g:13722:1: ( ( rule__IndexedColumn__ColumnReferenceAssignment_0 ) )
            {
            // InternalMickeyLang.g:13722:1: ( ( rule__IndexedColumn__ColumnReferenceAssignment_0 ) )
            // InternalMickeyLang.g:13723:2: ( rule__IndexedColumn__ColumnReferenceAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getColumnReferenceAssignment_0()); 
            }
            // InternalMickeyLang.g:13724:2: ( rule__IndexedColumn__ColumnReferenceAssignment_0 )
            // InternalMickeyLang.g:13724:3: rule__IndexedColumn__ColumnReferenceAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__ColumnReferenceAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getColumnReferenceAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group__0__Impl"


    // $ANTLR start "rule__IndexedColumn__Group__1"
    // InternalMickeyLang.g:13732:1: rule__IndexedColumn__Group__1 : rule__IndexedColumn__Group__1__Impl rule__IndexedColumn__Group__2 ;
    public final void rule__IndexedColumn__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13736:1: ( rule__IndexedColumn__Group__1__Impl rule__IndexedColumn__Group__2 )
            // InternalMickeyLang.g:13737:2: rule__IndexedColumn__Group__1__Impl rule__IndexedColumn__Group__2
            {
            pushFollow(FOLLOW_110);
            rule__IndexedColumn__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group__1"


    // $ANTLR start "rule__IndexedColumn__Group__1__Impl"
    // InternalMickeyLang.g:13744:1: rule__IndexedColumn__Group__1__Impl : ( ( rule__IndexedColumn__Group_1__0 )? ) ;
    public final void rule__IndexedColumn__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13748:1: ( ( ( rule__IndexedColumn__Group_1__0 )? ) )
            // InternalMickeyLang.g:13749:1: ( ( rule__IndexedColumn__Group_1__0 )? )
            {
            // InternalMickeyLang.g:13749:1: ( ( rule__IndexedColumn__Group_1__0 )? )
            // InternalMickeyLang.g:13750:2: ( rule__IndexedColumn__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:13751:2: ( rule__IndexedColumn__Group_1__0 )?
            int alt117=2;
            int LA117_0 = input.LA(1);

            if ( (LA117_0==109) ) {
                alt117=1;
            }
            switch (alt117) {
                case 1 :
                    // InternalMickeyLang.g:13751:3: rule__IndexedColumn__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__IndexedColumn__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group__1__Impl"


    // $ANTLR start "rule__IndexedColumn__Group__2"
    // InternalMickeyLang.g:13759:1: rule__IndexedColumn__Group__2 : rule__IndexedColumn__Group__2__Impl ;
    public final void rule__IndexedColumn__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13763:1: ( rule__IndexedColumn__Group__2__Impl )
            // InternalMickeyLang.g:13764:2: rule__IndexedColumn__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group__2"


    // $ANTLR start "rule__IndexedColumn__Group__2__Impl"
    // InternalMickeyLang.g:13770:1: rule__IndexedColumn__Group__2__Impl : ( ( rule__IndexedColumn__Alternatives_2 )? ) ;
    public final void rule__IndexedColumn__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13774:1: ( ( ( rule__IndexedColumn__Alternatives_2 )? ) )
            // InternalMickeyLang.g:13775:1: ( ( rule__IndexedColumn__Alternatives_2 )? )
            {
            // InternalMickeyLang.g:13775:1: ( ( rule__IndexedColumn__Alternatives_2 )? )
            // InternalMickeyLang.g:13776:2: ( rule__IndexedColumn__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getAlternatives_2()); 
            }
            // InternalMickeyLang.g:13777:2: ( rule__IndexedColumn__Alternatives_2 )?
            int alt118=2;
            int LA118_0 = input.LA(1);

            if ( ((LA118_0>=124 && LA118_0<=125)) ) {
                alt118=1;
            }
            switch (alt118) {
                case 1 :
                    // InternalMickeyLang.g:13777:3: rule__IndexedColumn__Alternatives_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__IndexedColumn__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getAlternatives_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group__2__Impl"


    // $ANTLR start "rule__IndexedColumn__Group_1__0"
    // InternalMickeyLang.g:13786:1: rule__IndexedColumn__Group_1__0 : rule__IndexedColumn__Group_1__0__Impl rule__IndexedColumn__Group_1__1 ;
    public final void rule__IndexedColumn__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13790:1: ( rule__IndexedColumn__Group_1__0__Impl rule__IndexedColumn__Group_1__1 )
            // InternalMickeyLang.g:13791:2: rule__IndexedColumn__Group_1__0__Impl rule__IndexedColumn__Group_1__1
            {
            pushFollow(FOLLOW_3);
            rule__IndexedColumn__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group_1__0"


    // $ANTLR start "rule__IndexedColumn__Group_1__0__Impl"
    // InternalMickeyLang.g:13798:1: rule__IndexedColumn__Group_1__0__Impl : ( 'collate' ) ;
    public final void rule__IndexedColumn__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13802:1: ( ( 'collate' ) )
            // InternalMickeyLang.g:13803:1: ( 'collate' )
            {
            // InternalMickeyLang.g:13803:1: ( 'collate' )
            // InternalMickeyLang.g:13804:2: 'collate'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getCollateKeyword_1_0()); 
            }
            match(input,109,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getCollateKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group_1__0__Impl"


    // $ANTLR start "rule__IndexedColumn__Group_1__1"
    // InternalMickeyLang.g:13813:1: rule__IndexedColumn__Group_1__1 : rule__IndexedColumn__Group_1__1__Impl ;
    public final void rule__IndexedColumn__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13817:1: ( rule__IndexedColumn__Group_1__1__Impl )
            // InternalMickeyLang.g:13818:2: rule__IndexedColumn__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group_1__1"


    // $ANTLR start "rule__IndexedColumn__Group_1__1__Impl"
    // InternalMickeyLang.g:13824:1: rule__IndexedColumn__Group_1__1__Impl : ( ( rule__IndexedColumn__CollationNameAssignment_1_1 ) ) ;
    public final void rule__IndexedColumn__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13828:1: ( ( ( rule__IndexedColumn__CollationNameAssignment_1_1 ) ) )
            // InternalMickeyLang.g:13829:1: ( ( rule__IndexedColumn__CollationNameAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:13829:1: ( ( rule__IndexedColumn__CollationNameAssignment_1_1 ) )
            // InternalMickeyLang.g:13830:2: ( rule__IndexedColumn__CollationNameAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getCollationNameAssignment_1_1()); 
            }
            // InternalMickeyLang.g:13831:2: ( rule__IndexedColumn__CollationNameAssignment_1_1 )
            // InternalMickeyLang.g:13831:3: rule__IndexedColumn__CollationNameAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__IndexedColumn__CollationNameAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getCollationNameAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__Group_1__1__Impl"


    // $ANTLR start "rule__DefaultValue__Group_0__0"
    // InternalMickeyLang.g:13840:1: rule__DefaultValue__Group_0__0 : rule__DefaultValue__Group_0__0__Impl rule__DefaultValue__Group_0__1 ;
    public final void rule__DefaultValue__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13844:1: ( rule__DefaultValue__Group_0__0__Impl rule__DefaultValue__Group_0__1 )
            // InternalMickeyLang.g:13845:2: rule__DefaultValue__Group_0__0__Impl rule__DefaultValue__Group_0__1
            {
            pushFollow(FOLLOW_51);
            rule__DefaultValue__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_0__0"


    // $ANTLR start "rule__DefaultValue__Group_0__0__Impl"
    // InternalMickeyLang.g:13852:1: rule__DefaultValue__Group_0__0__Impl : ( () ) ;
    public final void rule__DefaultValue__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13856:1: ( ( () ) )
            // InternalMickeyLang.g:13857:1: ( () )
            {
            // InternalMickeyLang.g:13857:1: ( () )
            // InternalMickeyLang.g:13858:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getLiteralDefaultValueAction_0_0()); 
            }
            // InternalMickeyLang.g:13859:2: ()
            // InternalMickeyLang.g:13859:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getLiteralDefaultValueAction_0_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_0__0__Impl"


    // $ANTLR start "rule__DefaultValue__Group_0__1"
    // InternalMickeyLang.g:13867:1: rule__DefaultValue__Group_0__1 : rule__DefaultValue__Group_0__1__Impl ;
    public final void rule__DefaultValue__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13871:1: ( rule__DefaultValue__Group_0__1__Impl )
            // InternalMickeyLang.g:13872:2: rule__DefaultValue__Group_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_0__1"


    // $ANTLR start "rule__DefaultValue__Group_0__1__Impl"
    // InternalMickeyLang.g:13878:1: rule__DefaultValue__Group_0__1__Impl : ( ( rule__DefaultValue__LiteralAssignment_0_1 ) ) ;
    public final void rule__DefaultValue__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13882:1: ( ( ( rule__DefaultValue__LiteralAssignment_0_1 ) ) )
            // InternalMickeyLang.g:13883:1: ( ( rule__DefaultValue__LiteralAssignment_0_1 ) )
            {
            // InternalMickeyLang.g:13883:1: ( ( rule__DefaultValue__LiteralAssignment_0_1 ) )
            // InternalMickeyLang.g:13884:2: ( rule__DefaultValue__LiteralAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getLiteralAssignment_0_1()); 
            }
            // InternalMickeyLang.g:13885:2: ( rule__DefaultValue__LiteralAssignment_0_1 )
            // InternalMickeyLang.g:13885:3: rule__DefaultValue__LiteralAssignment_0_1
            {
            pushFollow(FOLLOW_2);
            rule__DefaultValue__LiteralAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getLiteralAssignment_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_0__1__Impl"


    // $ANTLR start "rule__DefaultValue__Group_1__0"
    // InternalMickeyLang.g:13894:1: rule__DefaultValue__Group_1__0 : rule__DefaultValue__Group_1__0__Impl rule__DefaultValue__Group_1__1 ;
    public final void rule__DefaultValue__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13898:1: ( rule__DefaultValue__Group_1__0__Impl rule__DefaultValue__Group_1__1 )
            // InternalMickeyLang.g:13899:2: rule__DefaultValue__Group_1__0__Impl rule__DefaultValue__Group_1__1
            {
            pushFollow(FOLLOW_107);
            rule__DefaultValue__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__0"


    // $ANTLR start "rule__DefaultValue__Group_1__0__Impl"
    // InternalMickeyLang.g:13906:1: rule__DefaultValue__Group_1__0__Impl : ( () ) ;
    public final void rule__DefaultValue__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13910:1: ( ( () ) )
            // InternalMickeyLang.g:13911:1: ( () )
            {
            // InternalMickeyLang.g:13911:1: ( () )
            // InternalMickeyLang.g:13912:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getExpressionDefaultValueAction_1_0()); 
            }
            // InternalMickeyLang.g:13913:2: ()
            // InternalMickeyLang.g:13913:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getExpressionDefaultValueAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__0__Impl"


    // $ANTLR start "rule__DefaultValue__Group_1__1"
    // InternalMickeyLang.g:13921:1: rule__DefaultValue__Group_1__1 : rule__DefaultValue__Group_1__1__Impl rule__DefaultValue__Group_1__2 ;
    public final void rule__DefaultValue__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13925:1: ( rule__DefaultValue__Group_1__1__Impl rule__DefaultValue__Group_1__2 )
            // InternalMickeyLang.g:13926:2: rule__DefaultValue__Group_1__1__Impl rule__DefaultValue__Group_1__2
            {
            pushFollow(FOLLOW_30);
            rule__DefaultValue__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__1"


    // $ANTLR start "rule__DefaultValue__Group_1__1__Impl"
    // InternalMickeyLang.g:13933:1: rule__DefaultValue__Group_1__1__Impl : ( '(' ) ;
    public final void rule__DefaultValue__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13937:1: ( ( '(' ) )
            // InternalMickeyLang.g:13938:1: ( '(' )
            {
            // InternalMickeyLang.g:13938:1: ( '(' )
            // InternalMickeyLang.g:13939:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getLeftParenthesisKeyword_1_1()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getLeftParenthesisKeyword_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__1__Impl"


    // $ANTLR start "rule__DefaultValue__Group_1__2"
    // InternalMickeyLang.g:13948:1: rule__DefaultValue__Group_1__2 : rule__DefaultValue__Group_1__2__Impl rule__DefaultValue__Group_1__3 ;
    public final void rule__DefaultValue__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13952:1: ( rule__DefaultValue__Group_1__2__Impl rule__DefaultValue__Group_1__3 )
            // InternalMickeyLang.g:13953:2: rule__DefaultValue__Group_1__2__Impl rule__DefaultValue__Group_1__3
            {
            pushFollow(FOLLOW_52);
            rule__DefaultValue__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__2"


    // $ANTLR start "rule__DefaultValue__Group_1__2__Impl"
    // InternalMickeyLang.g:13960:1: rule__DefaultValue__Group_1__2__Impl : ( ( rule__DefaultValue__ExpressionAssignment_1_2 ) ) ;
    public final void rule__DefaultValue__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13964:1: ( ( ( rule__DefaultValue__ExpressionAssignment_1_2 ) ) )
            // InternalMickeyLang.g:13965:1: ( ( rule__DefaultValue__ExpressionAssignment_1_2 ) )
            {
            // InternalMickeyLang.g:13965:1: ( ( rule__DefaultValue__ExpressionAssignment_1_2 ) )
            // InternalMickeyLang.g:13966:2: ( rule__DefaultValue__ExpressionAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getExpressionAssignment_1_2()); 
            }
            // InternalMickeyLang.g:13967:2: ( rule__DefaultValue__ExpressionAssignment_1_2 )
            // InternalMickeyLang.g:13967:3: rule__DefaultValue__ExpressionAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__DefaultValue__ExpressionAssignment_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getExpressionAssignment_1_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__2__Impl"


    // $ANTLR start "rule__DefaultValue__Group_1__3"
    // InternalMickeyLang.g:13975:1: rule__DefaultValue__Group_1__3 : rule__DefaultValue__Group_1__3__Impl ;
    public final void rule__DefaultValue__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13979:1: ( rule__DefaultValue__Group_1__3__Impl )
            // InternalMickeyLang.g:13980:2: rule__DefaultValue__Group_1__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DefaultValue__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__3"


    // $ANTLR start "rule__DefaultValue__Group_1__3__Impl"
    // InternalMickeyLang.g:13986:1: rule__DefaultValue__Group_1__3__Impl : ( ')' ) ;
    public final void rule__DefaultValue__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:13990:1: ( ( ')' ) )
            // InternalMickeyLang.g:13991:1: ( ')' )
            {
            // InternalMickeyLang.g:13991:1: ( ')' )
            // InternalMickeyLang.g:13992:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getRightParenthesisKeyword_1_3()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getRightParenthesisKeyword_1_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__Group_1__3__Impl"


    // $ANTLR start "rule__ConflictClause__Group__0"
    // InternalMickeyLang.g:14002:1: rule__ConflictClause__Group__0 : rule__ConflictClause__Group__0__Impl rule__ConflictClause__Group__1 ;
    public final void rule__ConflictClause__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14006:1: ( rule__ConflictClause__Group__0__Impl rule__ConflictClause__Group__1 )
            // InternalMickeyLang.g:14007:2: rule__ConflictClause__Group__0__Impl rule__ConflictClause__Group__1
            {
            pushFollow(FOLLOW_111);
            rule__ConflictClause__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ConflictClause__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__Group__0"


    // $ANTLR start "rule__ConflictClause__Group__0__Impl"
    // InternalMickeyLang.g:14014:1: rule__ConflictClause__Group__0__Impl : ( 'on' ) ;
    public final void rule__ConflictClause__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14018:1: ( ( 'on' ) )
            // InternalMickeyLang.g:14019:1: ( 'on' )
            {
            // InternalMickeyLang.g:14019:1: ( 'on' )
            // InternalMickeyLang.g:14020:2: 'on'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictClauseAccess().getOnKeyword_0()); 
            }
            match(input,69,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictClauseAccess().getOnKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__Group__0__Impl"


    // $ANTLR start "rule__ConflictClause__Group__1"
    // InternalMickeyLang.g:14029:1: rule__ConflictClause__Group__1 : rule__ConflictClause__Group__1__Impl rule__ConflictClause__Group__2 ;
    public final void rule__ConflictClause__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14033:1: ( rule__ConflictClause__Group__1__Impl rule__ConflictClause__Group__2 )
            // InternalMickeyLang.g:14034:2: rule__ConflictClause__Group__1__Impl rule__ConflictClause__Group__2
            {
            pushFollow(FOLLOW_112);
            rule__ConflictClause__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ConflictClause__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__Group__1"


    // $ANTLR start "rule__ConflictClause__Group__1__Impl"
    // InternalMickeyLang.g:14041:1: rule__ConflictClause__Group__1__Impl : ( 'conflict' ) ;
    public final void rule__ConflictClause__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14045:1: ( ( 'conflict' ) )
            // InternalMickeyLang.g:14046:1: ( 'conflict' )
            {
            // InternalMickeyLang.g:14046:1: ( 'conflict' )
            // InternalMickeyLang.g:14047:2: 'conflict'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictClauseAccess().getConflictKeyword_1()); 
            }
            match(input,110,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictClauseAccess().getConflictKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__Group__1__Impl"


    // $ANTLR start "rule__ConflictClause__Group__2"
    // InternalMickeyLang.g:14056:1: rule__ConflictClause__Group__2 : rule__ConflictClause__Group__2__Impl ;
    public final void rule__ConflictClause__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14060:1: ( rule__ConflictClause__Group__2__Impl )
            // InternalMickeyLang.g:14061:2: rule__ConflictClause__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ConflictClause__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__Group__2"


    // $ANTLR start "rule__ConflictClause__Group__2__Impl"
    // InternalMickeyLang.g:14067:1: rule__ConflictClause__Group__2__Impl : ( ( rule__ConflictClause__ResolutionAssignment_2 ) ) ;
    public final void rule__ConflictClause__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14071:1: ( ( ( rule__ConflictClause__ResolutionAssignment_2 ) ) )
            // InternalMickeyLang.g:14072:1: ( ( rule__ConflictClause__ResolutionAssignment_2 ) )
            {
            // InternalMickeyLang.g:14072:1: ( ( rule__ConflictClause__ResolutionAssignment_2 ) )
            // InternalMickeyLang.g:14073:2: ( rule__ConflictClause__ResolutionAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictClauseAccess().getResolutionAssignment_2()); 
            }
            // InternalMickeyLang.g:14074:2: ( rule__ConflictClause__ResolutionAssignment_2 )
            // InternalMickeyLang.g:14074:3: rule__ConflictClause__ResolutionAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ConflictClause__ResolutionAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictClauseAccess().getResolutionAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__Group__2__Impl"


    // $ANTLR start "rule__DeleteStatement__Group__0"
    // InternalMickeyLang.g:14083:1: rule__DeleteStatement__Group__0 : rule__DeleteStatement__Group__0__Impl rule__DeleteStatement__Group__1 ;
    public final void rule__DeleteStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14087:1: ( rule__DeleteStatement__Group__0__Impl rule__DeleteStatement__Group__1 )
            // InternalMickeyLang.g:14088:2: rule__DeleteStatement__Group__0__Impl rule__DeleteStatement__Group__1
            {
            pushFollow(FOLLOW_113);
            rule__DeleteStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__0"


    // $ANTLR start "rule__DeleteStatement__Group__0__Impl"
    // InternalMickeyLang.g:14095:1: rule__DeleteStatement__Group__0__Impl : ( 'delete' ) ;
    public final void rule__DeleteStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14099:1: ( ( 'delete' ) )
            // InternalMickeyLang.g:14100:1: ( 'delete' )
            {
            // InternalMickeyLang.g:14100:1: ( 'delete' )
            // InternalMickeyLang.g:14101:2: 'delete'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getDeleteKeyword_0()); 
            }
            match(input,111,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getDeleteKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__0__Impl"


    // $ANTLR start "rule__DeleteStatement__Group__1"
    // InternalMickeyLang.g:14110:1: rule__DeleteStatement__Group__1 : rule__DeleteStatement__Group__1__Impl rule__DeleteStatement__Group__2 ;
    public final void rule__DeleteStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14114:1: ( rule__DeleteStatement__Group__1__Impl rule__DeleteStatement__Group__2 )
            // InternalMickeyLang.g:14115:2: rule__DeleteStatement__Group__1__Impl rule__DeleteStatement__Group__2
            {
            pushFollow(FOLLOW_3);
            rule__DeleteStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__1"


    // $ANTLR start "rule__DeleteStatement__Group__1__Impl"
    // InternalMickeyLang.g:14122:1: rule__DeleteStatement__Group__1__Impl : ( 'from' ) ;
    public final void rule__DeleteStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14126:1: ( ( 'from' ) )
            // InternalMickeyLang.g:14127:1: ( 'from' )
            {
            // InternalMickeyLang.g:14127:1: ( 'from' )
            // InternalMickeyLang.g:14128:2: 'from'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getFromKeyword_1()); 
            }
            match(input,73,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getFromKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__1__Impl"


    // $ANTLR start "rule__DeleteStatement__Group__2"
    // InternalMickeyLang.g:14137:1: rule__DeleteStatement__Group__2 : rule__DeleteStatement__Group__2__Impl rule__DeleteStatement__Group__3 ;
    public final void rule__DeleteStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14141:1: ( rule__DeleteStatement__Group__2__Impl rule__DeleteStatement__Group__3 )
            // InternalMickeyLang.g:14142:2: rule__DeleteStatement__Group__2__Impl rule__DeleteStatement__Group__3
            {
            pushFollow(FOLLOW_114);
            rule__DeleteStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__2"


    // $ANTLR start "rule__DeleteStatement__Group__2__Impl"
    // InternalMickeyLang.g:14149:1: rule__DeleteStatement__Group__2__Impl : ( ( rule__DeleteStatement__TableAssignment_2 ) ) ;
    public final void rule__DeleteStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14153:1: ( ( ( rule__DeleteStatement__TableAssignment_2 ) ) )
            // InternalMickeyLang.g:14154:1: ( ( rule__DeleteStatement__TableAssignment_2 ) )
            {
            // InternalMickeyLang.g:14154:1: ( ( rule__DeleteStatement__TableAssignment_2 ) )
            // InternalMickeyLang.g:14155:2: ( rule__DeleteStatement__TableAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getTableAssignment_2()); 
            }
            // InternalMickeyLang.g:14156:2: ( rule__DeleteStatement__TableAssignment_2 )
            // InternalMickeyLang.g:14156:3: rule__DeleteStatement__TableAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__TableAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getTableAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__2__Impl"


    // $ANTLR start "rule__DeleteStatement__Group__3"
    // InternalMickeyLang.g:14164:1: rule__DeleteStatement__Group__3 : rule__DeleteStatement__Group__3__Impl ;
    public final void rule__DeleteStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14168:1: ( rule__DeleteStatement__Group__3__Impl )
            // InternalMickeyLang.g:14169:2: rule__DeleteStatement__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__3"


    // $ANTLR start "rule__DeleteStatement__Group__3__Impl"
    // InternalMickeyLang.g:14175:1: rule__DeleteStatement__Group__3__Impl : ( ( rule__DeleteStatement__Group_3__0 )? ) ;
    public final void rule__DeleteStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14179:1: ( ( ( rule__DeleteStatement__Group_3__0 )? ) )
            // InternalMickeyLang.g:14180:1: ( ( rule__DeleteStatement__Group_3__0 )? )
            {
            // InternalMickeyLang.g:14180:1: ( ( rule__DeleteStatement__Group_3__0 )? )
            // InternalMickeyLang.g:14181:2: ( rule__DeleteStatement__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getGroup_3()); 
            }
            // InternalMickeyLang.g:14182:2: ( rule__DeleteStatement__Group_3__0 )?
            int alt119=2;
            int LA119_0 = input.LA(1);

            if ( (LA119_0==89) ) {
                alt119=1;
            }
            switch (alt119) {
                case 1 :
                    // InternalMickeyLang.g:14182:3: rule__DeleteStatement__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__DeleteStatement__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getGroup_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group__3__Impl"


    // $ANTLR start "rule__DeleteStatement__Group_3__0"
    // InternalMickeyLang.g:14191:1: rule__DeleteStatement__Group_3__0 : rule__DeleteStatement__Group_3__0__Impl rule__DeleteStatement__Group_3__1 ;
    public final void rule__DeleteStatement__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14195:1: ( rule__DeleteStatement__Group_3__0__Impl rule__DeleteStatement__Group_3__1 )
            // InternalMickeyLang.g:14196:2: rule__DeleteStatement__Group_3__0__Impl rule__DeleteStatement__Group_3__1
            {
            pushFollow(FOLLOW_30);
            rule__DeleteStatement__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group_3__0"


    // $ANTLR start "rule__DeleteStatement__Group_3__0__Impl"
    // InternalMickeyLang.g:14203:1: rule__DeleteStatement__Group_3__0__Impl : ( 'where' ) ;
    public final void rule__DeleteStatement__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14207:1: ( ( 'where' ) )
            // InternalMickeyLang.g:14208:1: ( 'where' )
            {
            // InternalMickeyLang.g:14208:1: ( 'where' )
            // InternalMickeyLang.g:14209:2: 'where'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getWhereKeyword_3_0()); 
            }
            match(input,89,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getWhereKeyword_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group_3__0__Impl"


    // $ANTLR start "rule__DeleteStatement__Group_3__1"
    // InternalMickeyLang.g:14218:1: rule__DeleteStatement__Group_3__1 : rule__DeleteStatement__Group_3__1__Impl ;
    public final void rule__DeleteStatement__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14222:1: ( rule__DeleteStatement__Group_3__1__Impl )
            // InternalMickeyLang.g:14223:2: rule__DeleteStatement__Group_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group_3__1"


    // $ANTLR start "rule__DeleteStatement__Group_3__1__Impl"
    // InternalMickeyLang.g:14229:1: rule__DeleteStatement__Group_3__1__Impl : ( ( rule__DeleteStatement__ExpressionAssignment_3_1 ) ) ;
    public final void rule__DeleteStatement__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14233:1: ( ( ( rule__DeleteStatement__ExpressionAssignment_3_1 ) ) )
            // InternalMickeyLang.g:14234:1: ( ( rule__DeleteStatement__ExpressionAssignment_3_1 ) )
            {
            // InternalMickeyLang.g:14234:1: ( ( rule__DeleteStatement__ExpressionAssignment_3_1 ) )
            // InternalMickeyLang.g:14235:2: ( rule__DeleteStatement__ExpressionAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getExpressionAssignment_3_1()); 
            }
            // InternalMickeyLang.g:14236:2: ( rule__DeleteStatement__ExpressionAssignment_3_1 )
            // InternalMickeyLang.g:14236:3: rule__DeleteStatement__ExpressionAssignment_3_1
            {
            pushFollow(FOLLOW_2);
            rule__DeleteStatement__ExpressionAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getExpressionAssignment_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__Group_3__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group__0"
    // InternalMickeyLang.g:14245:1: rule__InsertStatement__Group__0 : rule__InsertStatement__Group__0__Impl rule__InsertStatement__Group__1 ;
    public final void rule__InsertStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14249:1: ( rule__InsertStatement__Group__0__Impl rule__InsertStatement__Group__1 )
            // InternalMickeyLang.g:14250:2: rule__InsertStatement__Group__0__Impl rule__InsertStatement__Group__1
            {
            pushFollow(FOLLOW_115);
            rule__InsertStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__0"


    // $ANTLR start "rule__InsertStatement__Group__0__Impl"
    // InternalMickeyLang.g:14257:1: rule__InsertStatement__Group__0__Impl : ( ( rule__InsertStatement__Alternatives_0 ) ) ;
    public final void rule__InsertStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14261:1: ( ( ( rule__InsertStatement__Alternatives_0 ) ) )
            // InternalMickeyLang.g:14262:1: ( ( rule__InsertStatement__Alternatives_0 ) )
            {
            // InternalMickeyLang.g:14262:1: ( ( rule__InsertStatement__Alternatives_0 ) )
            // InternalMickeyLang.g:14263:2: ( rule__InsertStatement__Alternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getAlternatives_0()); 
            }
            // InternalMickeyLang.g:14264:2: ( rule__InsertStatement__Alternatives_0 )
            // InternalMickeyLang.g:14264:3: rule__InsertStatement__Alternatives_0
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Alternatives_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getAlternatives_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group__1"
    // InternalMickeyLang.g:14272:1: rule__InsertStatement__Group__1 : rule__InsertStatement__Group__1__Impl rule__InsertStatement__Group__2 ;
    public final void rule__InsertStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14276:1: ( rule__InsertStatement__Group__1__Impl rule__InsertStatement__Group__2 )
            // InternalMickeyLang.g:14277:2: rule__InsertStatement__Group__1__Impl rule__InsertStatement__Group__2
            {
            pushFollow(FOLLOW_3);
            rule__InsertStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__1"


    // $ANTLR start "rule__InsertStatement__Group__1__Impl"
    // InternalMickeyLang.g:14284:1: rule__InsertStatement__Group__1__Impl : ( 'into' ) ;
    public final void rule__InsertStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14288:1: ( ( 'into' ) )
            // InternalMickeyLang.g:14289:1: ( 'into' )
            {
            // InternalMickeyLang.g:14289:1: ( 'into' )
            // InternalMickeyLang.g:14290:2: 'into'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getIntoKeyword_1()); 
            }
            match(input,112,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getIntoKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group__2"
    // InternalMickeyLang.g:14299:1: rule__InsertStatement__Group__2 : rule__InsertStatement__Group__2__Impl rule__InsertStatement__Group__3 ;
    public final void rule__InsertStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14303:1: ( rule__InsertStatement__Group__2__Impl rule__InsertStatement__Group__3 )
            // InternalMickeyLang.g:14304:2: rule__InsertStatement__Group__2__Impl rule__InsertStatement__Group__3
            {
            pushFollow(FOLLOW_116);
            rule__InsertStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__2"


    // $ANTLR start "rule__InsertStatement__Group__2__Impl"
    // InternalMickeyLang.g:14311:1: rule__InsertStatement__Group__2__Impl : ( ( rule__InsertStatement__TableAssignment_2 ) ) ;
    public final void rule__InsertStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14315:1: ( ( ( rule__InsertStatement__TableAssignment_2 ) ) )
            // InternalMickeyLang.g:14316:1: ( ( rule__InsertStatement__TableAssignment_2 ) )
            {
            // InternalMickeyLang.g:14316:1: ( ( rule__InsertStatement__TableAssignment_2 ) )
            // InternalMickeyLang.g:14317:2: ( rule__InsertStatement__TableAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getTableAssignment_2()); 
            }
            // InternalMickeyLang.g:14318:2: ( rule__InsertStatement__TableAssignment_2 )
            // InternalMickeyLang.g:14318:3: rule__InsertStatement__TableAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__TableAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getTableAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__2__Impl"


    // $ANTLR start "rule__InsertStatement__Group__3"
    // InternalMickeyLang.g:14326:1: rule__InsertStatement__Group__3 : rule__InsertStatement__Group__3__Impl rule__InsertStatement__Group__4 ;
    public final void rule__InsertStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14330:1: ( rule__InsertStatement__Group__3__Impl rule__InsertStatement__Group__4 )
            // InternalMickeyLang.g:14331:2: rule__InsertStatement__Group__3__Impl rule__InsertStatement__Group__4
            {
            pushFollow(FOLLOW_116);
            rule__InsertStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__3"


    // $ANTLR start "rule__InsertStatement__Group__3__Impl"
    // InternalMickeyLang.g:14338:1: rule__InsertStatement__Group__3__Impl : ( ( rule__InsertStatement__Group_3__0 )? ) ;
    public final void rule__InsertStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14342:1: ( ( ( rule__InsertStatement__Group_3__0 )? ) )
            // InternalMickeyLang.g:14343:1: ( ( rule__InsertStatement__Group_3__0 )? )
            {
            // InternalMickeyLang.g:14343:1: ( ( rule__InsertStatement__Group_3__0 )? )
            // InternalMickeyLang.g:14344:2: ( rule__InsertStatement__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getGroup_3()); 
            }
            // InternalMickeyLang.g:14345:2: ( rule__InsertStatement__Group_3__0 )?
            int alt120=2;
            int LA120_0 = input.LA(1);

            if ( (LA120_0==62) ) {
                alt120=1;
            }
            switch (alt120) {
                case 1 :
                    // InternalMickeyLang.g:14345:3: rule__InsertStatement__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getGroup_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__3__Impl"


    // $ANTLR start "rule__InsertStatement__Group__4"
    // InternalMickeyLang.g:14353:1: rule__InsertStatement__Group__4 : rule__InsertStatement__Group__4__Impl ;
    public final void rule__InsertStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14357:1: ( rule__InsertStatement__Group__4__Impl )
            // InternalMickeyLang.g:14358:2: rule__InsertStatement__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__4"


    // $ANTLR start "rule__InsertStatement__Group__4__Impl"
    // InternalMickeyLang.g:14364:1: rule__InsertStatement__Group__4__Impl : ( ( rule__InsertStatement__Alternatives_4 ) ) ;
    public final void rule__InsertStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14368:1: ( ( ( rule__InsertStatement__Alternatives_4 ) ) )
            // InternalMickeyLang.g:14369:1: ( ( rule__InsertStatement__Alternatives_4 ) )
            {
            // InternalMickeyLang.g:14369:1: ( ( rule__InsertStatement__Alternatives_4 ) )
            // InternalMickeyLang.g:14370:2: ( rule__InsertStatement__Alternatives_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getAlternatives_4()); 
            }
            // InternalMickeyLang.g:14371:2: ( rule__InsertStatement__Alternatives_4 )
            // InternalMickeyLang.g:14371:3: rule__InsertStatement__Alternatives_4
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Alternatives_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getAlternatives_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group__4__Impl"


    // $ANTLR start "rule__InsertStatement__Group_0_0__0"
    // InternalMickeyLang.g:14380:1: rule__InsertStatement__Group_0_0__0 : rule__InsertStatement__Group_0_0__0__Impl rule__InsertStatement__Group_0_0__1 ;
    public final void rule__InsertStatement__Group_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14384:1: ( rule__InsertStatement__Group_0_0__0__Impl rule__InsertStatement__Group_0_0__1 )
            // InternalMickeyLang.g:14385:2: rule__InsertStatement__Group_0_0__0__Impl rule__InsertStatement__Group_0_0__1
            {
            pushFollow(FOLLOW_43);
            rule__InsertStatement__Group_0_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_0_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0__0"


    // $ANTLR start "rule__InsertStatement__Group_0_0__0__Impl"
    // InternalMickeyLang.g:14392:1: rule__InsertStatement__Group_0_0__0__Impl : ( 'insert' ) ;
    public final void rule__InsertStatement__Group_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14396:1: ( ( 'insert' ) )
            // InternalMickeyLang.g:14397:1: ( 'insert' )
            {
            // InternalMickeyLang.g:14397:1: ( 'insert' )
            // InternalMickeyLang.g:14398:2: 'insert'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getInsertKeyword_0_0_0()); 
            }
            match(input,113,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getInsertKeyword_0_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_0_0__1"
    // InternalMickeyLang.g:14407:1: rule__InsertStatement__Group_0_0__1 : rule__InsertStatement__Group_0_0__1__Impl ;
    public final void rule__InsertStatement__Group_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14411:1: ( rule__InsertStatement__Group_0_0__1__Impl )
            // InternalMickeyLang.g:14412:2: rule__InsertStatement__Group_0_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_0_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0__1"


    // $ANTLR start "rule__InsertStatement__Group_0_0__1__Impl"
    // InternalMickeyLang.g:14418:1: rule__InsertStatement__Group_0_0__1__Impl : ( ( rule__InsertStatement__Group_0_0_1__0 )? ) ;
    public final void rule__InsertStatement__Group_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14422:1: ( ( ( rule__InsertStatement__Group_0_0_1__0 )? ) )
            // InternalMickeyLang.g:14423:1: ( ( rule__InsertStatement__Group_0_0_1__0 )? )
            {
            // InternalMickeyLang.g:14423:1: ( ( rule__InsertStatement__Group_0_0_1__0 )? )
            // InternalMickeyLang.g:14424:2: ( rule__InsertStatement__Group_0_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getGroup_0_0_1()); 
            }
            // InternalMickeyLang.g:14425:2: ( rule__InsertStatement__Group_0_0_1__0 )?
            int alt121=2;
            int LA121_0 = input.LA(1);

            if ( (LA121_0==114) ) {
                alt121=1;
            }
            switch (alt121) {
                case 1 :
                    // InternalMickeyLang.g:14425:3: rule__InsertStatement__Group_0_0_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__InsertStatement__Group_0_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getGroup_0_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group_0_0_1__0"
    // InternalMickeyLang.g:14434:1: rule__InsertStatement__Group_0_0_1__0 : rule__InsertStatement__Group_0_0_1__0__Impl rule__InsertStatement__Group_0_0_1__1 ;
    public final void rule__InsertStatement__Group_0_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14438:1: ( rule__InsertStatement__Group_0_0_1__0__Impl rule__InsertStatement__Group_0_0_1__1 )
            // InternalMickeyLang.g:14439:2: rule__InsertStatement__Group_0_0_1__0__Impl rule__InsertStatement__Group_0_0_1__1
            {
            pushFollow(FOLLOW_112);
            rule__InsertStatement__Group_0_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_0_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0_1__0"


    // $ANTLR start "rule__InsertStatement__Group_0_0_1__0__Impl"
    // InternalMickeyLang.g:14446:1: rule__InsertStatement__Group_0_0_1__0__Impl : ( 'or' ) ;
    public final void rule__InsertStatement__Group_0_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14450:1: ( ( 'or' ) )
            // InternalMickeyLang.g:14451:1: ( 'or' )
            {
            // InternalMickeyLang.g:14451:1: ( 'or' )
            // InternalMickeyLang.g:14452:2: 'or'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getOrKeyword_0_0_1_0()); 
            }
            match(input,114,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getOrKeyword_0_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0_1__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_0_0_1__1"
    // InternalMickeyLang.g:14461:1: rule__InsertStatement__Group_0_0_1__1 : rule__InsertStatement__Group_0_0_1__1__Impl ;
    public final void rule__InsertStatement__Group_0_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14465:1: ( rule__InsertStatement__Group_0_0_1__1__Impl )
            // InternalMickeyLang.g:14466:2: rule__InsertStatement__Group_0_0_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_0_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0_1__1"


    // $ANTLR start "rule__InsertStatement__Group_0_0_1__1__Impl"
    // InternalMickeyLang.g:14472:1: rule__InsertStatement__Group_0_0_1__1__Impl : ( ( rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 ) ) ;
    public final void rule__InsertStatement__Group_0_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14476:1: ( ( ( rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 ) ) )
            // InternalMickeyLang.g:14477:1: ( ( rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 ) )
            {
            // InternalMickeyLang.g:14477:1: ( ( rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 ) )
            // InternalMickeyLang.g:14478:2: ( rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getConflictResolutionAssignment_0_0_1_1()); 
            }
            // InternalMickeyLang.g:14479:2: ( rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 )
            // InternalMickeyLang.g:14479:3: rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getConflictResolutionAssignment_0_0_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_0_0_1__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group_3__0"
    // InternalMickeyLang.g:14488:1: rule__InsertStatement__Group_3__0 : rule__InsertStatement__Group_3__0__Impl rule__InsertStatement__Group_3__1 ;
    public final void rule__InsertStatement__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14492:1: ( rule__InsertStatement__Group_3__0__Impl rule__InsertStatement__Group_3__1 )
            // InternalMickeyLang.g:14493:2: rule__InsertStatement__Group_3__0__Impl rule__InsertStatement__Group_3__1
            {
            pushFollow(FOLLOW_3);
            rule__InsertStatement__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__0"


    // $ANTLR start "rule__InsertStatement__Group_3__0__Impl"
    // InternalMickeyLang.g:14500:1: rule__InsertStatement__Group_3__0__Impl : ( '(' ) ;
    public final void rule__InsertStatement__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14504:1: ( ( '(' ) )
            // InternalMickeyLang.g:14505:1: ( '(' )
            {
            // InternalMickeyLang.g:14505:1: ( '(' )
            // InternalMickeyLang.g:14506:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getLeftParenthesisKeyword_3_0()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getLeftParenthesisKeyword_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_3__1"
    // InternalMickeyLang.g:14515:1: rule__InsertStatement__Group_3__1 : rule__InsertStatement__Group_3__1__Impl rule__InsertStatement__Group_3__2 ;
    public final void rule__InsertStatement__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14519:1: ( rule__InsertStatement__Group_3__1__Impl rule__InsertStatement__Group_3__2 )
            // InternalMickeyLang.g:14520:2: rule__InsertStatement__Group_3__1__Impl rule__InsertStatement__Group_3__2
            {
            pushFollow(FOLLOW_82);
            rule__InsertStatement__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_3__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__1"


    // $ANTLR start "rule__InsertStatement__Group_3__1__Impl"
    // InternalMickeyLang.g:14527:1: rule__InsertStatement__Group_3__1__Impl : ( ( rule__InsertStatement__ColumnNamesAssignment_3_1 ) ) ;
    public final void rule__InsertStatement__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14531:1: ( ( ( rule__InsertStatement__ColumnNamesAssignment_3_1 ) ) )
            // InternalMickeyLang.g:14532:1: ( ( rule__InsertStatement__ColumnNamesAssignment_3_1 ) )
            {
            // InternalMickeyLang.g:14532:1: ( ( rule__InsertStatement__ColumnNamesAssignment_3_1 ) )
            // InternalMickeyLang.g:14533:2: ( rule__InsertStatement__ColumnNamesAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getColumnNamesAssignment_3_1()); 
            }
            // InternalMickeyLang.g:14534:2: ( rule__InsertStatement__ColumnNamesAssignment_3_1 )
            // InternalMickeyLang.g:14534:3: rule__InsertStatement__ColumnNamesAssignment_3_1
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__ColumnNamesAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getColumnNamesAssignment_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group_3__2"
    // InternalMickeyLang.g:14542:1: rule__InsertStatement__Group_3__2 : rule__InsertStatement__Group_3__2__Impl rule__InsertStatement__Group_3__3 ;
    public final void rule__InsertStatement__Group_3__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14546:1: ( rule__InsertStatement__Group_3__2__Impl rule__InsertStatement__Group_3__3 )
            // InternalMickeyLang.g:14547:2: rule__InsertStatement__Group_3__2__Impl rule__InsertStatement__Group_3__3
            {
            pushFollow(FOLLOW_82);
            rule__InsertStatement__Group_3__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_3__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__2"


    // $ANTLR start "rule__InsertStatement__Group_3__2__Impl"
    // InternalMickeyLang.g:14554:1: rule__InsertStatement__Group_3__2__Impl : ( ( rule__InsertStatement__Group_3_2__0 )* ) ;
    public final void rule__InsertStatement__Group_3__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14558:1: ( ( ( rule__InsertStatement__Group_3_2__0 )* ) )
            // InternalMickeyLang.g:14559:1: ( ( rule__InsertStatement__Group_3_2__0 )* )
            {
            // InternalMickeyLang.g:14559:1: ( ( rule__InsertStatement__Group_3_2__0 )* )
            // InternalMickeyLang.g:14560:2: ( rule__InsertStatement__Group_3_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getGroup_3_2()); 
            }
            // InternalMickeyLang.g:14561:2: ( rule__InsertStatement__Group_3_2__0 )*
            loop122:
            do {
                int alt122=2;
                int LA122_0 = input.LA(1);

                if ( (LA122_0==40) ) {
                    alt122=1;
                }


                switch (alt122) {
            	case 1 :
            	    // InternalMickeyLang.g:14561:3: rule__InsertStatement__Group_3_2__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__InsertStatement__Group_3_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop122;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getGroup_3_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__2__Impl"


    // $ANTLR start "rule__InsertStatement__Group_3__3"
    // InternalMickeyLang.g:14569:1: rule__InsertStatement__Group_3__3 : rule__InsertStatement__Group_3__3__Impl ;
    public final void rule__InsertStatement__Group_3__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14573:1: ( rule__InsertStatement__Group_3__3__Impl )
            // InternalMickeyLang.g:14574:2: rule__InsertStatement__Group_3__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_3__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__3"


    // $ANTLR start "rule__InsertStatement__Group_3__3__Impl"
    // InternalMickeyLang.g:14580:1: rule__InsertStatement__Group_3__3__Impl : ( ')' ) ;
    public final void rule__InsertStatement__Group_3__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14584:1: ( ( ')' ) )
            // InternalMickeyLang.g:14585:1: ( ')' )
            {
            // InternalMickeyLang.g:14585:1: ( ')' )
            // InternalMickeyLang.g:14586:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getRightParenthesisKeyword_3_3()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getRightParenthesisKeyword_3_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3__3__Impl"


    // $ANTLR start "rule__InsertStatement__Group_3_2__0"
    // InternalMickeyLang.g:14596:1: rule__InsertStatement__Group_3_2__0 : rule__InsertStatement__Group_3_2__0__Impl rule__InsertStatement__Group_3_2__1 ;
    public final void rule__InsertStatement__Group_3_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14600:1: ( rule__InsertStatement__Group_3_2__0__Impl rule__InsertStatement__Group_3_2__1 )
            // InternalMickeyLang.g:14601:2: rule__InsertStatement__Group_3_2__0__Impl rule__InsertStatement__Group_3_2__1
            {
            pushFollow(FOLLOW_3);
            rule__InsertStatement__Group_3_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_3_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3_2__0"


    // $ANTLR start "rule__InsertStatement__Group_3_2__0__Impl"
    // InternalMickeyLang.g:14608:1: rule__InsertStatement__Group_3_2__0__Impl : ( ',' ) ;
    public final void rule__InsertStatement__Group_3_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14612:1: ( ( ',' ) )
            // InternalMickeyLang.g:14613:1: ( ',' )
            {
            // InternalMickeyLang.g:14613:1: ( ',' )
            // InternalMickeyLang.g:14614:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getCommaKeyword_3_2_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getCommaKeyword_3_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3_2__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_3_2__1"
    // InternalMickeyLang.g:14623:1: rule__InsertStatement__Group_3_2__1 : rule__InsertStatement__Group_3_2__1__Impl ;
    public final void rule__InsertStatement__Group_3_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14627:1: ( rule__InsertStatement__Group_3_2__1__Impl )
            // InternalMickeyLang.g:14628:2: rule__InsertStatement__Group_3_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_3_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3_2__1"


    // $ANTLR start "rule__InsertStatement__Group_3_2__1__Impl"
    // InternalMickeyLang.g:14634:1: rule__InsertStatement__Group_3_2__1__Impl : ( ( rule__InsertStatement__ColumnNamesAssignment_3_2_1 ) ) ;
    public final void rule__InsertStatement__Group_3_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14638:1: ( ( ( rule__InsertStatement__ColumnNamesAssignment_3_2_1 ) ) )
            // InternalMickeyLang.g:14639:1: ( ( rule__InsertStatement__ColumnNamesAssignment_3_2_1 ) )
            {
            // InternalMickeyLang.g:14639:1: ( ( rule__InsertStatement__ColumnNamesAssignment_3_2_1 ) )
            // InternalMickeyLang.g:14640:2: ( rule__InsertStatement__ColumnNamesAssignment_3_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getColumnNamesAssignment_3_2_1()); 
            }
            // InternalMickeyLang.g:14641:2: ( rule__InsertStatement__ColumnNamesAssignment_3_2_1 )
            // InternalMickeyLang.g:14641:3: rule__InsertStatement__ColumnNamesAssignment_3_2_1
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__ColumnNamesAssignment_3_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getColumnNamesAssignment_3_2_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_3_2__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__0"
    // InternalMickeyLang.g:14650:1: rule__InsertStatement__Group_4_0_0__0 : rule__InsertStatement__Group_4_0_0__0__Impl rule__InsertStatement__Group_4_0_0__1 ;
    public final void rule__InsertStatement__Group_4_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14654:1: ( rule__InsertStatement__Group_4_0_0__0__Impl rule__InsertStatement__Group_4_0_0__1 )
            // InternalMickeyLang.g:14655:2: rule__InsertStatement__Group_4_0_0__0__Impl rule__InsertStatement__Group_4_0_0__1
            {
            pushFollow(FOLLOW_6);
            rule__InsertStatement__Group_4_0_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__0"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__0__Impl"
    // InternalMickeyLang.g:14662:1: rule__InsertStatement__Group_4_0_0__0__Impl : ( 'values' ) ;
    public final void rule__InsertStatement__Group_4_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14666:1: ( ( 'values' ) )
            // InternalMickeyLang.g:14667:1: ( 'values' )
            {
            // InternalMickeyLang.g:14667:1: ( 'values' )
            // InternalMickeyLang.g:14668:2: 'values'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getValuesKeyword_4_0_0_0()); 
            }
            match(input,115,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getValuesKeyword_4_0_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__1"
    // InternalMickeyLang.g:14677:1: rule__InsertStatement__Group_4_0_0__1 : rule__InsertStatement__Group_4_0_0__1__Impl rule__InsertStatement__Group_4_0_0__2 ;
    public final void rule__InsertStatement__Group_4_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14681:1: ( rule__InsertStatement__Group_4_0_0__1__Impl rule__InsertStatement__Group_4_0_0__2 )
            // InternalMickeyLang.g:14682:2: rule__InsertStatement__Group_4_0_0__1__Impl rule__InsertStatement__Group_4_0_0__2
            {
            pushFollow(FOLLOW_30);
            rule__InsertStatement__Group_4_0_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__1"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__1__Impl"
    // InternalMickeyLang.g:14689:1: rule__InsertStatement__Group_4_0_0__1__Impl : ( '(' ) ;
    public final void rule__InsertStatement__Group_4_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14693:1: ( ( '(' ) )
            // InternalMickeyLang.g:14694:1: ( '(' )
            {
            // InternalMickeyLang.g:14694:1: ( '(' )
            // InternalMickeyLang.g:14695:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getLeftParenthesisKeyword_4_0_0_1()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getLeftParenthesisKeyword_4_0_0_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__2"
    // InternalMickeyLang.g:14704:1: rule__InsertStatement__Group_4_0_0__2 : rule__InsertStatement__Group_4_0_0__2__Impl rule__InsertStatement__Group_4_0_0__3 ;
    public final void rule__InsertStatement__Group_4_0_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14708:1: ( rule__InsertStatement__Group_4_0_0__2__Impl rule__InsertStatement__Group_4_0_0__3 )
            // InternalMickeyLang.g:14709:2: rule__InsertStatement__Group_4_0_0__2__Impl rule__InsertStatement__Group_4_0_0__3
            {
            pushFollow(FOLLOW_82);
            rule__InsertStatement__Group_4_0_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__2"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__2__Impl"
    // InternalMickeyLang.g:14716:1: rule__InsertStatement__Group_4_0_0__2__Impl : ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_2 ) ) ;
    public final void rule__InsertStatement__Group_4_0_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14720:1: ( ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_2 ) ) )
            // InternalMickeyLang.g:14721:1: ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_2 ) )
            {
            // InternalMickeyLang.g:14721:1: ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_2 ) )
            // InternalMickeyLang.g:14722:2: ( rule__InsertStatement__ExpressionsAssignment_4_0_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getExpressionsAssignment_4_0_0_2()); 
            }
            // InternalMickeyLang.g:14723:2: ( rule__InsertStatement__ExpressionsAssignment_4_0_0_2 )
            // InternalMickeyLang.g:14723:3: rule__InsertStatement__ExpressionsAssignment_4_0_0_2
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__ExpressionsAssignment_4_0_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getExpressionsAssignment_4_0_0_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__2__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__3"
    // InternalMickeyLang.g:14731:1: rule__InsertStatement__Group_4_0_0__3 : rule__InsertStatement__Group_4_0_0__3__Impl rule__InsertStatement__Group_4_0_0__4 ;
    public final void rule__InsertStatement__Group_4_0_0__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14735:1: ( rule__InsertStatement__Group_4_0_0__3__Impl rule__InsertStatement__Group_4_0_0__4 )
            // InternalMickeyLang.g:14736:2: rule__InsertStatement__Group_4_0_0__3__Impl rule__InsertStatement__Group_4_0_0__4
            {
            pushFollow(FOLLOW_82);
            rule__InsertStatement__Group_4_0_0__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__3"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__3__Impl"
    // InternalMickeyLang.g:14743:1: rule__InsertStatement__Group_4_0_0__3__Impl : ( ( rule__InsertStatement__Group_4_0_0_3__0 )* ) ;
    public final void rule__InsertStatement__Group_4_0_0__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14747:1: ( ( ( rule__InsertStatement__Group_4_0_0_3__0 )* ) )
            // InternalMickeyLang.g:14748:1: ( ( rule__InsertStatement__Group_4_0_0_3__0 )* )
            {
            // InternalMickeyLang.g:14748:1: ( ( rule__InsertStatement__Group_4_0_0_3__0 )* )
            // InternalMickeyLang.g:14749:2: ( rule__InsertStatement__Group_4_0_0_3__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getGroup_4_0_0_3()); 
            }
            // InternalMickeyLang.g:14750:2: ( rule__InsertStatement__Group_4_0_0_3__0 )*
            loop123:
            do {
                int alt123=2;
                int LA123_0 = input.LA(1);

                if ( (LA123_0==40) ) {
                    alt123=1;
                }


                switch (alt123) {
            	case 1 :
            	    // InternalMickeyLang.g:14750:3: rule__InsertStatement__Group_4_0_0_3__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__InsertStatement__Group_4_0_0_3__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop123;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getGroup_4_0_0_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__3__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__4"
    // InternalMickeyLang.g:14758:1: rule__InsertStatement__Group_4_0_0__4 : rule__InsertStatement__Group_4_0_0__4__Impl ;
    public final void rule__InsertStatement__Group_4_0_0__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14762:1: ( rule__InsertStatement__Group_4_0_0__4__Impl )
            // InternalMickeyLang.g:14763:2: rule__InsertStatement__Group_4_0_0__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__4"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0__4__Impl"
    // InternalMickeyLang.g:14769:1: rule__InsertStatement__Group_4_0_0__4__Impl : ( ')' ) ;
    public final void rule__InsertStatement__Group_4_0_0__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14773:1: ( ( ')' ) )
            // InternalMickeyLang.g:14774:1: ( ')' )
            {
            // InternalMickeyLang.g:14774:1: ( ')' )
            // InternalMickeyLang.g:14775:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getRightParenthesisKeyword_4_0_0_4()); 
            }
            match(input,63,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getRightParenthesisKeyword_4_0_0_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0__4__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0_3__0"
    // InternalMickeyLang.g:14785:1: rule__InsertStatement__Group_4_0_0_3__0 : rule__InsertStatement__Group_4_0_0_3__0__Impl rule__InsertStatement__Group_4_0_0_3__1 ;
    public final void rule__InsertStatement__Group_4_0_0_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14789:1: ( rule__InsertStatement__Group_4_0_0_3__0__Impl rule__InsertStatement__Group_4_0_0_3__1 )
            // InternalMickeyLang.g:14790:2: rule__InsertStatement__Group_4_0_0_3__0__Impl rule__InsertStatement__Group_4_0_0_3__1
            {
            pushFollow(FOLLOW_30);
            rule__InsertStatement__Group_4_0_0_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0_3__0"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0_3__0__Impl"
    // InternalMickeyLang.g:14797:1: rule__InsertStatement__Group_4_0_0_3__0__Impl : ( ',' ) ;
    public final void rule__InsertStatement__Group_4_0_0_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14801:1: ( ( ',' ) )
            // InternalMickeyLang.g:14802:1: ( ',' )
            {
            // InternalMickeyLang.g:14802:1: ( ',' )
            // InternalMickeyLang.g:14803:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getCommaKeyword_4_0_0_3_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getCommaKeyword_4_0_0_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0_3__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0_3__1"
    // InternalMickeyLang.g:14812:1: rule__InsertStatement__Group_4_0_0_3__1 : rule__InsertStatement__Group_4_0_0_3__1__Impl ;
    public final void rule__InsertStatement__Group_4_0_0_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14816:1: ( rule__InsertStatement__Group_4_0_0_3__1__Impl )
            // InternalMickeyLang.g:14817:2: rule__InsertStatement__Group_4_0_0_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_0_0_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0_3__1"


    // $ANTLR start "rule__InsertStatement__Group_4_0_0_3__1__Impl"
    // InternalMickeyLang.g:14823:1: rule__InsertStatement__Group_4_0_0_3__1__Impl : ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 ) ) ;
    public final void rule__InsertStatement__Group_4_0_0_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14827:1: ( ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 ) ) )
            // InternalMickeyLang.g:14828:1: ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 ) )
            {
            // InternalMickeyLang.g:14828:1: ( ( rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 ) )
            // InternalMickeyLang.g:14829:2: ( rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getExpressionsAssignment_4_0_0_3_1()); 
            }
            // InternalMickeyLang.g:14830:2: ( rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 )
            // InternalMickeyLang.g:14830:3: rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getExpressionsAssignment_4_0_0_3_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_0_0_3__1__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_1__0"
    // InternalMickeyLang.g:14839:1: rule__InsertStatement__Group_4_1__0 : rule__InsertStatement__Group_4_1__0__Impl rule__InsertStatement__Group_4_1__1 ;
    public final void rule__InsertStatement__Group_4_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14843:1: ( rule__InsertStatement__Group_4_1__0__Impl rule__InsertStatement__Group_4_1__1 )
            // InternalMickeyLang.g:14844:2: rule__InsertStatement__Group_4_1__0__Impl rule__InsertStatement__Group_4_1__1
            {
            pushFollow(FOLLOW_117);
            rule__InsertStatement__Group_4_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_1__0"


    // $ANTLR start "rule__InsertStatement__Group_4_1__0__Impl"
    // InternalMickeyLang.g:14851:1: rule__InsertStatement__Group_4_1__0__Impl : ( 'default' ) ;
    public final void rule__InsertStatement__Group_4_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14855:1: ( ( 'default' ) )
            // InternalMickeyLang.g:14856:1: ( 'default' )
            {
            // InternalMickeyLang.g:14856:1: ( 'default' )
            // InternalMickeyLang.g:14857:2: 'default'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getDefaultKeyword_4_1_0()); 
            }
            match(input,106,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getDefaultKeyword_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_1__0__Impl"


    // $ANTLR start "rule__InsertStatement__Group_4_1__1"
    // InternalMickeyLang.g:14866:1: rule__InsertStatement__Group_4_1__1 : rule__InsertStatement__Group_4_1__1__Impl ;
    public final void rule__InsertStatement__Group_4_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14870:1: ( rule__InsertStatement__Group_4_1__1__Impl )
            // InternalMickeyLang.g:14871:2: rule__InsertStatement__Group_4_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InsertStatement__Group_4_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_1__1"


    // $ANTLR start "rule__InsertStatement__Group_4_1__1__Impl"
    // InternalMickeyLang.g:14877:1: rule__InsertStatement__Group_4_1__1__Impl : ( 'values' ) ;
    public final void rule__InsertStatement__Group_4_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14881:1: ( ( 'values' ) )
            // InternalMickeyLang.g:14882:1: ( 'values' )
            {
            // InternalMickeyLang.g:14882:1: ( 'values' )
            // InternalMickeyLang.g:14883:2: 'values'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getValuesKeyword_4_1_1()); 
            }
            match(input,115,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getValuesKeyword_4_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__Group_4_1__1__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__0"
    // InternalMickeyLang.g:14893:1: rule__UpdateStatement__Group__0 : rule__UpdateStatement__Group__0__Impl rule__UpdateStatement__Group__1 ;
    public final void rule__UpdateStatement__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14897:1: ( rule__UpdateStatement__Group__0__Impl rule__UpdateStatement__Group__1 )
            // InternalMickeyLang.g:14898:2: rule__UpdateStatement__Group__0__Impl rule__UpdateStatement__Group__1
            {
            pushFollow(FOLLOW_118);
            rule__UpdateStatement__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__0"


    // $ANTLR start "rule__UpdateStatement__Group__0__Impl"
    // InternalMickeyLang.g:14905:1: rule__UpdateStatement__Group__0__Impl : ( 'update' ) ;
    public final void rule__UpdateStatement__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14909:1: ( ( 'update' ) )
            // InternalMickeyLang.g:14910:1: ( 'update' )
            {
            // InternalMickeyLang.g:14910:1: ( 'update' )
            // InternalMickeyLang.g:14911:2: 'update'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getUpdateKeyword_0()); 
            }
            match(input,116,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getUpdateKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__0__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__1"
    // InternalMickeyLang.g:14920:1: rule__UpdateStatement__Group__1 : rule__UpdateStatement__Group__1__Impl rule__UpdateStatement__Group__2 ;
    public final void rule__UpdateStatement__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14924:1: ( rule__UpdateStatement__Group__1__Impl rule__UpdateStatement__Group__2 )
            // InternalMickeyLang.g:14925:2: rule__UpdateStatement__Group__1__Impl rule__UpdateStatement__Group__2
            {
            pushFollow(FOLLOW_118);
            rule__UpdateStatement__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__1"


    // $ANTLR start "rule__UpdateStatement__Group__1__Impl"
    // InternalMickeyLang.g:14932:1: rule__UpdateStatement__Group__1__Impl : ( ( rule__UpdateStatement__Group_1__0 )? ) ;
    public final void rule__UpdateStatement__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14936:1: ( ( ( rule__UpdateStatement__Group_1__0 )? ) )
            // InternalMickeyLang.g:14937:1: ( ( rule__UpdateStatement__Group_1__0 )? )
            {
            // InternalMickeyLang.g:14937:1: ( ( rule__UpdateStatement__Group_1__0 )? )
            // InternalMickeyLang.g:14938:2: ( rule__UpdateStatement__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:14939:2: ( rule__UpdateStatement__Group_1__0 )?
            int alt124=2;
            int LA124_0 = input.LA(1);

            if ( (LA124_0==114) ) {
                alt124=1;
            }
            switch (alt124) {
                case 1 :
                    // InternalMickeyLang.g:14939:3: rule__UpdateStatement__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__UpdateStatement__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__1__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__2"
    // InternalMickeyLang.g:14947:1: rule__UpdateStatement__Group__2 : rule__UpdateStatement__Group__2__Impl rule__UpdateStatement__Group__3 ;
    public final void rule__UpdateStatement__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14951:1: ( rule__UpdateStatement__Group__2__Impl rule__UpdateStatement__Group__3 )
            // InternalMickeyLang.g:14952:2: rule__UpdateStatement__Group__2__Impl rule__UpdateStatement__Group__3
            {
            pushFollow(FOLLOW_119);
            rule__UpdateStatement__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__2"


    // $ANTLR start "rule__UpdateStatement__Group__2__Impl"
    // InternalMickeyLang.g:14959:1: rule__UpdateStatement__Group__2__Impl : ( ( rule__UpdateStatement__TableAssignment_2 ) ) ;
    public final void rule__UpdateStatement__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14963:1: ( ( ( rule__UpdateStatement__TableAssignment_2 ) ) )
            // InternalMickeyLang.g:14964:1: ( ( rule__UpdateStatement__TableAssignment_2 ) )
            {
            // InternalMickeyLang.g:14964:1: ( ( rule__UpdateStatement__TableAssignment_2 ) )
            // InternalMickeyLang.g:14965:2: ( rule__UpdateStatement__TableAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getTableAssignment_2()); 
            }
            // InternalMickeyLang.g:14966:2: ( rule__UpdateStatement__TableAssignment_2 )
            // InternalMickeyLang.g:14966:3: rule__UpdateStatement__TableAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__TableAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getTableAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__2__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__3"
    // InternalMickeyLang.g:14974:1: rule__UpdateStatement__Group__3 : rule__UpdateStatement__Group__3__Impl rule__UpdateStatement__Group__4 ;
    public final void rule__UpdateStatement__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14978:1: ( rule__UpdateStatement__Group__3__Impl rule__UpdateStatement__Group__4 )
            // InternalMickeyLang.g:14979:2: rule__UpdateStatement__Group__3__Impl rule__UpdateStatement__Group__4
            {
            pushFollow(FOLLOW_3);
            rule__UpdateStatement__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__3"


    // $ANTLR start "rule__UpdateStatement__Group__3__Impl"
    // InternalMickeyLang.g:14986:1: rule__UpdateStatement__Group__3__Impl : ( 'set' ) ;
    public final void rule__UpdateStatement__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:14990:1: ( ( 'set' ) )
            // InternalMickeyLang.g:14991:1: ( 'set' )
            {
            // InternalMickeyLang.g:14991:1: ( 'set' )
            // InternalMickeyLang.g:14992:2: 'set'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getSetKeyword_3()); 
            }
            match(input,117,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getSetKeyword_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__3__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__4"
    // InternalMickeyLang.g:15001:1: rule__UpdateStatement__Group__4 : rule__UpdateStatement__Group__4__Impl rule__UpdateStatement__Group__5 ;
    public final void rule__UpdateStatement__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15005:1: ( rule__UpdateStatement__Group__4__Impl rule__UpdateStatement__Group__5 )
            // InternalMickeyLang.g:15006:2: rule__UpdateStatement__Group__4__Impl rule__UpdateStatement__Group__5
            {
            pushFollow(FOLLOW_120);
            rule__UpdateStatement__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__4"


    // $ANTLR start "rule__UpdateStatement__Group__4__Impl"
    // InternalMickeyLang.g:15013:1: rule__UpdateStatement__Group__4__Impl : ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 ) ) ;
    public final void rule__UpdateStatement__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15017:1: ( ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 ) ) )
            // InternalMickeyLang.g:15018:1: ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 ) )
            {
            // InternalMickeyLang.g:15018:1: ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 ) )
            // InternalMickeyLang.g:15019:2: ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsAssignment_4()); 
            }
            // InternalMickeyLang.g:15020:2: ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 )
            // InternalMickeyLang.g:15020:3: rule__UpdateStatement__UpdateColumnExpressionsAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__UpdateColumnExpressionsAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsAssignment_4()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__4__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__5"
    // InternalMickeyLang.g:15028:1: rule__UpdateStatement__Group__5 : rule__UpdateStatement__Group__5__Impl rule__UpdateStatement__Group__6 ;
    public final void rule__UpdateStatement__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15032:1: ( rule__UpdateStatement__Group__5__Impl rule__UpdateStatement__Group__6 )
            // InternalMickeyLang.g:15033:2: rule__UpdateStatement__Group__5__Impl rule__UpdateStatement__Group__6
            {
            pushFollow(FOLLOW_120);
            rule__UpdateStatement__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__5"


    // $ANTLR start "rule__UpdateStatement__Group__5__Impl"
    // InternalMickeyLang.g:15040:1: rule__UpdateStatement__Group__5__Impl : ( ( rule__UpdateStatement__Group_5__0 )* ) ;
    public final void rule__UpdateStatement__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15044:1: ( ( ( rule__UpdateStatement__Group_5__0 )* ) )
            // InternalMickeyLang.g:15045:1: ( ( rule__UpdateStatement__Group_5__0 )* )
            {
            // InternalMickeyLang.g:15045:1: ( ( rule__UpdateStatement__Group_5__0 )* )
            // InternalMickeyLang.g:15046:2: ( rule__UpdateStatement__Group_5__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getGroup_5()); 
            }
            // InternalMickeyLang.g:15047:2: ( rule__UpdateStatement__Group_5__0 )*
            loop125:
            do {
                int alt125=2;
                int LA125_0 = input.LA(1);

                if ( (LA125_0==40) ) {
                    alt125=1;
                }


                switch (alt125) {
            	case 1 :
            	    // InternalMickeyLang.g:15047:3: rule__UpdateStatement__Group_5__0
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__UpdateStatement__Group_5__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop125;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getGroup_5()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__5__Impl"


    // $ANTLR start "rule__UpdateStatement__Group__6"
    // InternalMickeyLang.g:15055:1: rule__UpdateStatement__Group__6 : rule__UpdateStatement__Group__6__Impl ;
    public final void rule__UpdateStatement__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15059:1: ( rule__UpdateStatement__Group__6__Impl )
            // InternalMickeyLang.g:15060:2: rule__UpdateStatement__Group__6__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__6"


    // $ANTLR start "rule__UpdateStatement__Group__6__Impl"
    // InternalMickeyLang.g:15066:1: rule__UpdateStatement__Group__6__Impl : ( ( rule__UpdateStatement__Group_6__0 )? ) ;
    public final void rule__UpdateStatement__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15070:1: ( ( ( rule__UpdateStatement__Group_6__0 )? ) )
            // InternalMickeyLang.g:15071:1: ( ( rule__UpdateStatement__Group_6__0 )? )
            {
            // InternalMickeyLang.g:15071:1: ( ( rule__UpdateStatement__Group_6__0 )? )
            // InternalMickeyLang.g:15072:2: ( rule__UpdateStatement__Group_6__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getGroup_6()); 
            }
            // InternalMickeyLang.g:15073:2: ( rule__UpdateStatement__Group_6__0 )?
            int alt126=2;
            int LA126_0 = input.LA(1);

            if ( (LA126_0==89) ) {
                alt126=1;
            }
            switch (alt126) {
                case 1 :
                    // InternalMickeyLang.g:15073:3: rule__UpdateStatement__Group_6__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__UpdateStatement__Group_6__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getGroup_6()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group__6__Impl"


    // $ANTLR start "rule__UpdateStatement__Group_1__0"
    // InternalMickeyLang.g:15082:1: rule__UpdateStatement__Group_1__0 : rule__UpdateStatement__Group_1__0__Impl rule__UpdateStatement__Group_1__1 ;
    public final void rule__UpdateStatement__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15086:1: ( rule__UpdateStatement__Group_1__0__Impl rule__UpdateStatement__Group_1__1 )
            // InternalMickeyLang.g:15087:2: rule__UpdateStatement__Group_1__0__Impl rule__UpdateStatement__Group_1__1
            {
            pushFollow(FOLLOW_112);
            rule__UpdateStatement__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_1__0"


    // $ANTLR start "rule__UpdateStatement__Group_1__0__Impl"
    // InternalMickeyLang.g:15094:1: rule__UpdateStatement__Group_1__0__Impl : ( 'or' ) ;
    public final void rule__UpdateStatement__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15098:1: ( ( 'or' ) )
            // InternalMickeyLang.g:15099:1: ( 'or' )
            {
            // InternalMickeyLang.g:15099:1: ( 'or' )
            // InternalMickeyLang.g:15100:2: 'or'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getOrKeyword_1_0()); 
            }
            match(input,114,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getOrKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_1__0__Impl"


    // $ANTLR start "rule__UpdateStatement__Group_1__1"
    // InternalMickeyLang.g:15109:1: rule__UpdateStatement__Group_1__1 : rule__UpdateStatement__Group_1__1__Impl ;
    public final void rule__UpdateStatement__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15113:1: ( rule__UpdateStatement__Group_1__1__Impl )
            // InternalMickeyLang.g:15114:2: rule__UpdateStatement__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_1__1"


    // $ANTLR start "rule__UpdateStatement__Group_1__1__Impl"
    // InternalMickeyLang.g:15120:1: rule__UpdateStatement__Group_1__1__Impl : ( ( rule__UpdateStatement__ConflictResolutionAssignment_1_1 ) ) ;
    public final void rule__UpdateStatement__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15124:1: ( ( ( rule__UpdateStatement__ConflictResolutionAssignment_1_1 ) ) )
            // InternalMickeyLang.g:15125:1: ( ( rule__UpdateStatement__ConflictResolutionAssignment_1_1 ) )
            {
            // InternalMickeyLang.g:15125:1: ( ( rule__UpdateStatement__ConflictResolutionAssignment_1_1 ) )
            // InternalMickeyLang.g:15126:2: ( rule__UpdateStatement__ConflictResolutionAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getConflictResolutionAssignment_1_1()); 
            }
            // InternalMickeyLang.g:15127:2: ( rule__UpdateStatement__ConflictResolutionAssignment_1_1 )
            // InternalMickeyLang.g:15127:3: rule__UpdateStatement__ConflictResolutionAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__ConflictResolutionAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getConflictResolutionAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_1__1__Impl"


    // $ANTLR start "rule__UpdateStatement__Group_5__0"
    // InternalMickeyLang.g:15136:1: rule__UpdateStatement__Group_5__0 : rule__UpdateStatement__Group_5__0__Impl rule__UpdateStatement__Group_5__1 ;
    public final void rule__UpdateStatement__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15140:1: ( rule__UpdateStatement__Group_5__0__Impl rule__UpdateStatement__Group_5__1 )
            // InternalMickeyLang.g:15141:2: rule__UpdateStatement__Group_5__0__Impl rule__UpdateStatement__Group_5__1
            {
            pushFollow(FOLLOW_3);
            rule__UpdateStatement__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_5__0"


    // $ANTLR start "rule__UpdateStatement__Group_5__0__Impl"
    // InternalMickeyLang.g:15148:1: rule__UpdateStatement__Group_5__0__Impl : ( ',' ) ;
    public final void rule__UpdateStatement__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15152:1: ( ( ',' ) )
            // InternalMickeyLang.g:15153:1: ( ',' )
            {
            // InternalMickeyLang.g:15153:1: ( ',' )
            // InternalMickeyLang.g:15154:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getCommaKeyword_5_0()); 
            }
            match(input,40,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getCommaKeyword_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_5__0__Impl"


    // $ANTLR start "rule__UpdateStatement__Group_5__1"
    // InternalMickeyLang.g:15163:1: rule__UpdateStatement__Group_5__1 : rule__UpdateStatement__Group_5__1__Impl ;
    public final void rule__UpdateStatement__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15167:1: ( rule__UpdateStatement__Group_5__1__Impl )
            // InternalMickeyLang.g:15168:2: rule__UpdateStatement__Group_5__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_5__1"


    // $ANTLR start "rule__UpdateStatement__Group_5__1__Impl"
    // InternalMickeyLang.g:15174:1: rule__UpdateStatement__Group_5__1__Impl : ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 ) ) ;
    public final void rule__UpdateStatement__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15178:1: ( ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 ) ) )
            // InternalMickeyLang.g:15179:1: ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 ) )
            {
            // InternalMickeyLang.g:15179:1: ( ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 ) )
            // InternalMickeyLang.g:15180:2: ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsAssignment_5_1()); 
            }
            // InternalMickeyLang.g:15181:2: ( rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 )
            // InternalMickeyLang.g:15181:3: rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsAssignment_5_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_5__1__Impl"


    // $ANTLR start "rule__UpdateStatement__Group_6__0"
    // InternalMickeyLang.g:15190:1: rule__UpdateStatement__Group_6__0 : rule__UpdateStatement__Group_6__0__Impl rule__UpdateStatement__Group_6__1 ;
    public final void rule__UpdateStatement__Group_6__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15194:1: ( rule__UpdateStatement__Group_6__0__Impl rule__UpdateStatement__Group_6__1 )
            // InternalMickeyLang.g:15195:2: rule__UpdateStatement__Group_6__0__Impl rule__UpdateStatement__Group_6__1
            {
            pushFollow(FOLLOW_30);
            rule__UpdateStatement__Group_6__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group_6__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_6__0"


    // $ANTLR start "rule__UpdateStatement__Group_6__0__Impl"
    // InternalMickeyLang.g:15202:1: rule__UpdateStatement__Group_6__0__Impl : ( 'where' ) ;
    public final void rule__UpdateStatement__Group_6__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15206:1: ( ( 'where' ) )
            // InternalMickeyLang.g:15207:1: ( 'where' )
            {
            // InternalMickeyLang.g:15207:1: ( 'where' )
            // InternalMickeyLang.g:15208:2: 'where'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getWhereKeyword_6_0()); 
            }
            match(input,89,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getWhereKeyword_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_6__0__Impl"


    // $ANTLR start "rule__UpdateStatement__Group_6__1"
    // InternalMickeyLang.g:15217:1: rule__UpdateStatement__Group_6__1 : rule__UpdateStatement__Group_6__1__Impl ;
    public final void rule__UpdateStatement__Group_6__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15221:1: ( rule__UpdateStatement__Group_6__1__Impl )
            // InternalMickeyLang.g:15222:2: rule__UpdateStatement__Group_6__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__Group_6__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_6__1"


    // $ANTLR start "rule__UpdateStatement__Group_6__1__Impl"
    // InternalMickeyLang.g:15228:1: rule__UpdateStatement__Group_6__1__Impl : ( ( rule__UpdateStatement__WhereExpressionAssignment_6_1 ) ) ;
    public final void rule__UpdateStatement__Group_6__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15232:1: ( ( ( rule__UpdateStatement__WhereExpressionAssignment_6_1 ) ) )
            // InternalMickeyLang.g:15233:1: ( ( rule__UpdateStatement__WhereExpressionAssignment_6_1 ) )
            {
            // InternalMickeyLang.g:15233:1: ( ( rule__UpdateStatement__WhereExpressionAssignment_6_1 ) )
            // InternalMickeyLang.g:15234:2: ( rule__UpdateStatement__WhereExpressionAssignment_6_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getWhereExpressionAssignment_6_1()); 
            }
            // InternalMickeyLang.g:15235:2: ( rule__UpdateStatement__WhereExpressionAssignment_6_1 )
            // InternalMickeyLang.g:15235:3: rule__UpdateStatement__WhereExpressionAssignment_6_1
            {
            pushFollow(FOLLOW_2);
            rule__UpdateStatement__WhereExpressionAssignment_6_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getWhereExpressionAssignment_6_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__Group_6__1__Impl"


    // $ANTLR start "rule__UpdateColumnExpression__Group__0"
    // InternalMickeyLang.g:15244:1: rule__UpdateColumnExpression__Group__0 : rule__UpdateColumnExpression__Group__0__Impl rule__UpdateColumnExpression__Group__1 ;
    public final void rule__UpdateColumnExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15248:1: ( rule__UpdateColumnExpression__Group__0__Impl rule__UpdateColumnExpression__Group__1 )
            // InternalMickeyLang.g:15249:2: rule__UpdateColumnExpression__Group__0__Impl rule__UpdateColumnExpression__Group__1
            {
            pushFollow(FOLLOW_121);
            rule__UpdateColumnExpression__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateColumnExpression__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__Group__0"


    // $ANTLR start "rule__UpdateColumnExpression__Group__0__Impl"
    // InternalMickeyLang.g:15256:1: rule__UpdateColumnExpression__Group__0__Impl : ( ( rule__UpdateColumnExpression__ColumnNameAssignment_0 ) ) ;
    public final void rule__UpdateColumnExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15260:1: ( ( ( rule__UpdateColumnExpression__ColumnNameAssignment_0 ) ) )
            // InternalMickeyLang.g:15261:1: ( ( rule__UpdateColumnExpression__ColumnNameAssignment_0 ) )
            {
            // InternalMickeyLang.g:15261:1: ( ( rule__UpdateColumnExpression__ColumnNameAssignment_0 ) )
            // InternalMickeyLang.g:15262:2: ( rule__UpdateColumnExpression__ColumnNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameAssignment_0()); 
            }
            // InternalMickeyLang.g:15263:2: ( rule__UpdateColumnExpression__ColumnNameAssignment_0 )
            // InternalMickeyLang.g:15263:3: rule__UpdateColumnExpression__ColumnNameAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__UpdateColumnExpression__ColumnNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__Group__0__Impl"


    // $ANTLR start "rule__UpdateColumnExpression__Group__1"
    // InternalMickeyLang.g:15271:1: rule__UpdateColumnExpression__Group__1 : rule__UpdateColumnExpression__Group__1__Impl rule__UpdateColumnExpression__Group__2 ;
    public final void rule__UpdateColumnExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15275:1: ( rule__UpdateColumnExpression__Group__1__Impl rule__UpdateColumnExpression__Group__2 )
            // InternalMickeyLang.g:15276:2: rule__UpdateColumnExpression__Group__1__Impl rule__UpdateColumnExpression__Group__2
            {
            pushFollow(FOLLOW_30);
            rule__UpdateColumnExpression__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__UpdateColumnExpression__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__Group__1"


    // $ANTLR start "rule__UpdateColumnExpression__Group__1__Impl"
    // InternalMickeyLang.g:15283:1: rule__UpdateColumnExpression__Group__1__Impl : ( '=' ) ;
    public final void rule__UpdateColumnExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15287:1: ( ( '=' ) )
            // InternalMickeyLang.g:15288:1: ( '=' )
            {
            // InternalMickeyLang.g:15288:1: ( '=' )
            // InternalMickeyLang.g:15289:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getEqualsSignKeyword_1()); 
            }
            match(input,25,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getEqualsSignKeyword_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__Group__1__Impl"


    // $ANTLR start "rule__UpdateColumnExpression__Group__2"
    // InternalMickeyLang.g:15298:1: rule__UpdateColumnExpression__Group__2 : rule__UpdateColumnExpression__Group__2__Impl ;
    public final void rule__UpdateColumnExpression__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15302:1: ( rule__UpdateColumnExpression__Group__2__Impl )
            // InternalMickeyLang.g:15303:2: rule__UpdateColumnExpression__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UpdateColumnExpression__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__Group__2"


    // $ANTLR start "rule__UpdateColumnExpression__Group__2__Impl"
    // InternalMickeyLang.g:15309:1: rule__UpdateColumnExpression__Group__2__Impl : ( ( rule__UpdateColumnExpression__ExpressionAssignment_2 ) ) ;
    public final void rule__UpdateColumnExpression__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15313:1: ( ( ( rule__UpdateColumnExpression__ExpressionAssignment_2 ) ) )
            // InternalMickeyLang.g:15314:1: ( ( rule__UpdateColumnExpression__ExpressionAssignment_2 ) )
            {
            // InternalMickeyLang.g:15314:1: ( ( rule__UpdateColumnExpression__ExpressionAssignment_2 ) )
            // InternalMickeyLang.g:15315:2: ( rule__UpdateColumnExpression__ExpressionAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getExpressionAssignment_2()); 
            }
            // InternalMickeyLang.g:15316:2: ( rule__UpdateColumnExpression__ExpressionAssignment_2 )
            // InternalMickeyLang.g:15316:3: rule__UpdateColumnExpression__ExpressionAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__UpdateColumnExpression__ExpressionAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getExpressionAssignment_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__Group__2__Impl"


    // $ANTLR start "rule__SignedNumber__Group__0"
    // InternalMickeyLang.g:15325:1: rule__SignedNumber__Group__0 : rule__SignedNumber__Group__0__Impl rule__SignedNumber__Group__1 ;
    public final void rule__SignedNumber__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15329:1: ( rule__SignedNumber__Group__0__Impl rule__SignedNumber__Group__1 )
            // InternalMickeyLang.g:15330:2: rule__SignedNumber__Group__0__Impl rule__SignedNumber__Group__1
            {
            pushFollow(FOLLOW_75);
            rule__SignedNumber__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__SignedNumber__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SignedNumber__Group__0"


    // $ANTLR start "rule__SignedNumber__Group__0__Impl"
    // InternalMickeyLang.g:15337:1: rule__SignedNumber__Group__0__Impl : ( ( '-' )? ) ;
    public final void rule__SignedNumber__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15341:1: ( ( ( '-' )? ) )
            // InternalMickeyLang.g:15342:1: ( ( '-' )? )
            {
            // InternalMickeyLang.g:15342:1: ( ( '-' )? )
            // InternalMickeyLang.g:15343:2: ( '-' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSignedNumberAccess().getHyphenMinusKeyword_0()); 
            }
            // InternalMickeyLang.g:15344:2: ( '-' )?
            int alt127=2;
            int LA127_0 = input.LA(1);

            if ( (LA127_0==16) ) {
                alt127=1;
            }
            switch (alt127) {
                case 1 :
                    // InternalMickeyLang.g:15344:3: '-'
                    {
                    match(input,16,FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSignedNumberAccess().getHyphenMinusKeyword_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SignedNumber__Group__0__Impl"


    // $ANTLR start "rule__SignedNumber__Group__1"
    // InternalMickeyLang.g:15352:1: rule__SignedNumber__Group__1 : rule__SignedNumber__Group__1__Impl ;
    public final void rule__SignedNumber__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15356:1: ( rule__SignedNumber__Group__1__Impl )
            // InternalMickeyLang.g:15357:2: rule__SignedNumber__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__SignedNumber__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SignedNumber__Group__1"


    // $ANTLR start "rule__SignedNumber__Group__1__Impl"
    // InternalMickeyLang.g:15363:1: rule__SignedNumber__Group__1__Impl : ( RULE_NUMBER ) ;
    public final void rule__SignedNumber__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15367:1: ( ( RULE_NUMBER ) )
            // InternalMickeyLang.g:15368:1: ( RULE_NUMBER )
            {
            // InternalMickeyLang.g:15368:1: ( RULE_NUMBER )
            // InternalMickeyLang.g:15369:2: RULE_NUMBER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSignedNumberAccess().getNUMBERTerminalRuleCall_1()); 
            }
            match(input,RULE_NUMBER,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSignedNumberAccess().getNUMBERTerminalRuleCall_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SignedNumber__Group__1__Impl"


    // $ANTLR start "rule__QualifiedName__Group__0"
    // InternalMickeyLang.g:15379:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ;
    public final void rule__QualifiedName__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15383:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 )
            // InternalMickeyLang.g:15384:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1
            {
            pushFollow(FOLLOW_49);
            rule__QualifiedName__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group__0"


    // $ANTLR start "rule__QualifiedName__Group__0__Impl"
    // InternalMickeyLang.g:15391:1: rule__QualifiedName__Group__0__Impl : ( RULE_ID ) ;
    public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15395:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15396:1: ( RULE_ID )
            {
            // InternalMickeyLang.g:15396:1: ( RULE_ID )
            // InternalMickeyLang.g:15397:2: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group__0__Impl"


    // $ANTLR start "rule__QualifiedName__Group__1"
    // InternalMickeyLang.g:15406:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ;
    public final void rule__QualifiedName__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15410:1: ( rule__QualifiedName__Group__1__Impl )
            // InternalMickeyLang.g:15411:2: rule__QualifiedName__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group__1"


    // $ANTLR start "rule__QualifiedName__Group__1__Impl"
    // InternalMickeyLang.g:15417:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ;
    public final void rule__QualifiedName__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15421:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) )
            // InternalMickeyLang.g:15422:1: ( ( rule__QualifiedName__Group_1__0 )* )
            {
            // InternalMickeyLang.g:15422:1: ( ( rule__QualifiedName__Group_1__0 )* )
            // InternalMickeyLang.g:15423:2: ( rule__QualifiedName__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameAccess().getGroup_1()); 
            }
            // InternalMickeyLang.g:15424:2: ( rule__QualifiedName__Group_1__0 )*
            loop128:
            do {
                int alt128=2;
                int LA128_0 = input.LA(1);

                if ( (LA128_0==77) ) {
                    alt128=1;
                }


                switch (alt128) {
            	case 1 :
            	    // InternalMickeyLang.g:15424:3: rule__QualifiedName__Group_1__0
            	    {
            	    pushFollow(FOLLOW_122);
            	    rule__QualifiedName__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop128;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getQualifiedNameAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group__1__Impl"


    // $ANTLR start "rule__QualifiedName__Group_1__0"
    // InternalMickeyLang.g:15433:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ;
    public final void rule__QualifiedName__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15437:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 )
            // InternalMickeyLang.g:15438:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1
            {
            pushFollow(FOLLOW_3);
            rule__QualifiedName__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group_1__0"


    // $ANTLR start "rule__QualifiedName__Group_1__0__Impl"
    // InternalMickeyLang.g:15445:1: rule__QualifiedName__Group_1__0__Impl : ( '.' ) ;
    public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15449:1: ( ( '.' ) )
            // InternalMickeyLang.g:15450:1: ( '.' )
            {
            // InternalMickeyLang.g:15450:1: ( '.' )
            // InternalMickeyLang.g:15451:2: '.'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
            }
            match(input,77,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group_1__0__Impl"


    // $ANTLR start "rule__QualifiedName__Group_1__1"
    // InternalMickeyLang.g:15460:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ;
    public final void rule__QualifiedName__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15464:1: ( rule__QualifiedName__Group_1__1__Impl )
            // InternalMickeyLang.g:15465:2: rule__QualifiedName__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group_1__1"


    // $ANTLR start "rule__QualifiedName__Group_1__1__Impl"
    // InternalMickeyLang.g:15471:1: rule__QualifiedName__Group_1__1__Impl : ( RULE_ID ) ;
    public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15475:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15476:1: ( RULE_ID )
            {
            // InternalMickeyLang.g:15476:1: ( RULE_ID )
            // InternalMickeyLang.g:15477:2: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__QualifiedName__Group_1__1__Impl"


    // $ANTLR start "rule__MickeyFile__DatabaseNameAssignment_1"
    // InternalMickeyLang.g:15487:1: rule__MickeyFile__DatabaseNameAssignment_1 : ( ruleQualifiedName ) ;
    public final void rule__MickeyFile__DatabaseNameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15491:1: ( ( ruleQualifiedName ) )
            // InternalMickeyLang.g:15492:2: ( ruleQualifiedName )
            {
            // InternalMickeyLang.g:15492:2: ( ruleQualifiedName )
            // InternalMickeyLang.g:15493:3: ruleQualifiedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileAccess().getDatabaseNameQualifiedNameParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileAccess().getDatabaseNameQualifiedNameParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__DatabaseNameAssignment_1"


    // $ANTLR start "rule__MickeyFile__BlocksAssignment_2"
    // InternalMickeyLang.g:15502:1: rule__MickeyFile__BlocksAssignment_2 : ( ruleMickeyBlock ) ;
    public final void rule__MickeyFile__BlocksAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15506:1: ( ( ruleMickeyBlock ) )
            // InternalMickeyLang.g:15507:2: ( ruleMickeyBlock )
            {
            // InternalMickeyLang.g:15507:2: ( ruleMickeyBlock )
            // InternalMickeyLang.g:15508:3: ruleMickeyBlock
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFileAccess().getBlocksMickeyBlockParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleMickeyBlock();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFileAccess().getBlocksMickeyBlockParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFile__BlocksAssignment_2"


    // $ANTLR start "rule__MickeyFunction__NameAssignment_1"
    // InternalMickeyLang.g:15517:1: rule__MickeyFunction__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__MickeyFunction__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15521:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15522:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15522:2: ( RULE_ID )
            // InternalMickeyLang.g:15523:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__NameAssignment_1"


    // $ANTLR start "rule__MickeyFunction__ArgsAssignment_3_0"
    // InternalMickeyLang.g:15532:1: rule__MickeyFunction__ArgsAssignment_3_0 : ( ruleFunctionArg ) ;
    public final void rule__MickeyFunction__ArgsAssignment_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15536:1: ( ( ruleFunctionArg ) )
            // InternalMickeyLang.g:15537:2: ( ruleFunctionArg )
            {
            // InternalMickeyLang.g:15537:2: ( ruleFunctionArg )
            // InternalMickeyLang.g:15538:3: ruleFunctionArg
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getArgsFunctionArgParserRuleCall_3_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleFunctionArg();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getArgsFunctionArgParserRuleCall_3_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__ArgsAssignment_3_0"


    // $ANTLR start "rule__MickeyFunction__ArgsAssignment_3_1_1"
    // InternalMickeyLang.g:15547:1: rule__MickeyFunction__ArgsAssignment_3_1_1 : ( ruleFunctionArg ) ;
    public final void rule__MickeyFunction__ArgsAssignment_3_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15551:1: ( ( ruleFunctionArg ) )
            // InternalMickeyLang.g:15552:2: ( ruleFunctionArg )
            {
            // InternalMickeyLang.g:15552:2: ( ruleFunctionArg )
            // InternalMickeyLang.g:15553:3: ruleFunctionArg
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getArgsFunctionArgParserRuleCall_3_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleFunctionArg();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getArgsFunctionArgParserRuleCall_3_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__ArgsAssignment_3_1_1"


    // $ANTLR start "rule__MickeyFunction__TypeAssignment_5_1"
    // InternalMickeyLang.g:15562:1: rule__MickeyFunction__TypeAssignment_5_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__MickeyFunction__TypeAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15566:1: ( ( ( ruleQualifiedName ) ) )
            // InternalMickeyLang.g:15567:2: ( ( ruleQualifiedName ) )
            {
            // InternalMickeyLang.g:15567:2: ( ( ruleQualifiedName ) )
            // InternalMickeyLang.g:15568:3: ( ruleQualifiedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getTypeTableDefinitionCrossReference_5_1_0()); 
            }
            // InternalMickeyLang.g:15569:3: ( ruleQualifiedName )
            // InternalMickeyLang.g:15570:4: ruleQualifiedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getTypeTableDefinitionQualifiedNameParserRuleCall_5_1_0_1()); 
            }
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getTypeTableDefinitionQualifiedNameParserRuleCall_5_1_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getTypeTableDefinitionCrossReference_5_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__TypeAssignment_5_1"


    // $ANTLR start "rule__MickeyFunction__StatementsAssignment_7_0"
    // InternalMickeyLang.g:15581:1: rule__MickeyFunction__StatementsAssignment_7_0 : ( ruleDMLStatement ) ;
    public final void rule__MickeyFunction__StatementsAssignment_7_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15585:1: ( ( ruleDMLStatement ) )
            // InternalMickeyLang.g:15586:2: ( ruleDMLStatement )
            {
            // InternalMickeyLang.g:15586:2: ( ruleDMLStatement )
            // InternalMickeyLang.g:15587:3: ruleDMLStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMickeyFunctionAccess().getStatementsDMLStatementParserRuleCall_7_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleDMLStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMickeyFunctionAccess().getStatementsDMLStatementParserRuleCall_7_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MickeyFunction__StatementsAssignment_7_0"


    // $ANTLR start "rule__ActionStatement__NameAssignment_1"
    // InternalMickeyLang.g:15596:1: rule__ActionStatement__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__ActionStatement__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15600:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15601:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15601:2: ( RULE_ID )
            // InternalMickeyLang.g:15602:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__NameAssignment_1"


    // $ANTLR start "rule__ActionStatement__UriAssignment_2"
    // InternalMickeyLang.g:15611:1: rule__ActionStatement__UriAssignment_2 : ( ruleContentUri ) ;
    public final void rule__ActionStatement__UriAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15615:1: ( ( ruleContentUri ) )
            // InternalMickeyLang.g:15616:2: ( ruleContentUri )
            {
            // InternalMickeyLang.g:15616:2: ( ruleContentUri )
            // InternalMickeyLang.g:15617:3: ruleContentUri
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getUriContentUriParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleContentUri();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getUriContentUriParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__UriAssignment_2"


    // $ANTLR start "rule__ActionStatement__TypeAssignment_4"
    // InternalMickeyLang.g:15626:1: rule__ActionStatement__TypeAssignment_4 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ActionStatement__TypeAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15630:1: ( ( ( ruleQualifiedName ) ) )
            // InternalMickeyLang.g:15631:2: ( ( ruleQualifiedName ) )
            {
            // InternalMickeyLang.g:15631:2: ( ( ruleQualifiedName ) )
            // InternalMickeyLang.g:15632:3: ( ruleQualifiedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getTypeTableDefinitionCrossReference_4_0()); 
            }
            // InternalMickeyLang.g:15633:3: ( ruleQualifiedName )
            // InternalMickeyLang.g:15634:4: ruleQualifiedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getTypeTableDefinitionQualifiedNameParserRuleCall_4_0_1()); 
            }
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getTypeTableDefinitionQualifiedNameParserRuleCall_4_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getTypeTableDefinitionCrossReference_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__TypeAssignment_4"


    // $ANTLR start "rule__ActionStatement__UniqueAssignment_5"
    // InternalMickeyLang.g:15645:1: rule__ActionStatement__UniqueAssignment_5 : ( ( 'unique' ) ) ;
    public final void rule__ActionStatement__UniqueAssignment_5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15649:1: ( ( ( 'unique' ) ) )
            // InternalMickeyLang.g:15650:2: ( ( 'unique' ) )
            {
            // InternalMickeyLang.g:15650:2: ( ( 'unique' ) )
            // InternalMickeyLang.g:15651:3: ( 'unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getUniqueUniqueKeyword_5_0()); 
            }
            // InternalMickeyLang.g:15652:3: ( 'unique' )
            // InternalMickeyLang.g:15653:4: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getUniqueUniqueKeyword_5_0()); 
            }
            match(input,105,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getUniqueUniqueKeyword_5_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getUniqueUniqueKeyword_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__UniqueAssignment_5"


    // $ANTLR start "rule__ActionStatement__ParamsAssignment_6_1"
    // InternalMickeyLang.g:15664:1: rule__ActionStatement__ParamsAssignment_6_1 : ( ruleContentUriQueryParam ) ;
    public final void rule__ActionStatement__ParamsAssignment_6_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15668:1: ( ( ruleContentUriQueryParam ) )
            // InternalMickeyLang.g:15669:2: ( ruleContentUriQueryParam )
            {
            // InternalMickeyLang.g:15669:2: ( ruleContentUriQueryParam )
            // InternalMickeyLang.g:15670:3: ruleContentUriQueryParam
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getParamsContentUriQueryParamParserRuleCall_6_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleContentUriQueryParam();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getParamsContentUriQueryParamParserRuleCall_6_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__ParamsAssignment_6_1"


    // $ANTLR start "rule__ActionStatement__NotificationsAssignment_6_2"
    // InternalMickeyLang.g:15679:1: rule__ActionStatement__NotificationsAssignment_6_2 : ( ruleContentNotificationUri ) ;
    public final void rule__ActionStatement__NotificationsAssignment_6_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15683:1: ( ( ruleContentNotificationUri ) )
            // InternalMickeyLang.g:15684:2: ( ruleContentNotificationUri )
            {
            // InternalMickeyLang.g:15684:2: ( ruleContentNotificationUri )
            // InternalMickeyLang.g:15685:3: ruleContentNotificationUri
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getActionStatementAccess().getNotificationsContentNotificationUriParserRuleCall_6_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleContentNotificationUri();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getActionStatementAccess().getNotificationsContentNotificationUriParserRuleCall_6_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ActionStatement__NotificationsAssignment_6_2"


    // $ANTLR start "rule__ContentNotificationUri__UriAssignment_1"
    // InternalMickeyLang.g:15694:1: rule__ContentNotificationUri__UriAssignment_1 : ( ruleNotifyContentUri ) ;
    public final void rule__ContentNotificationUri__UriAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15698:1: ( ( ruleNotifyContentUri ) )
            // InternalMickeyLang.g:15699:2: ( ruleNotifyContentUri )
            {
            // InternalMickeyLang.g:15699:2: ( ruleNotifyContentUri )
            // InternalMickeyLang.g:15700:3: ruleNotifyContentUri
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentNotificationUriAccess().getUriNotifyContentUriParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNotifyContentUri();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentNotificationUriAccess().getUriNotifyContentUriParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentNotificationUri__UriAssignment_1"


    // $ANTLR start "rule__FunctionArg__TypeAssignment_0"
    // InternalMickeyLang.g:15709:1: rule__FunctionArg__TypeAssignment_0 : ( ruleColumnType ) ;
    public final void rule__FunctionArg__TypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15713:1: ( ( ruleColumnType ) )
            // InternalMickeyLang.g:15714:2: ( ruleColumnType )
            {
            // InternalMickeyLang.g:15714:2: ( ruleColumnType )
            // InternalMickeyLang.g:15715:3: ruleColumnType
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFunctionArgAccess().getTypeColumnTypeEnumRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleColumnType();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFunctionArgAccess().getTypeColumnTypeEnumRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionArg__TypeAssignment_0"


    // $ANTLR start "rule__FunctionArg__NameAssignment_1"
    // InternalMickeyLang.g:15724:1: rule__FunctionArg__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__FunctionArg__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15728:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15729:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15729:2: ( RULE_ID )
            // InternalMickeyLang.g:15730:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFunctionArgAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFunctionArgAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionArg__NameAssignment_1"


    // $ANTLR start "rule__NotifyContentUri__SegmentsAssignment_1"
    // InternalMickeyLang.g:15739:1: rule__NotifyContentUri__SegmentsAssignment_1 : ( ruleNotifyContentUriSegment ) ;
    public final void rule__NotifyContentUri__SegmentsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15743:1: ( ( ruleNotifyContentUriSegment ) )
            // InternalMickeyLang.g:15744:2: ( ruleNotifyContentUriSegment )
            {
            // InternalMickeyLang.g:15744:2: ( ruleNotifyContentUriSegment )
            // InternalMickeyLang.g:15745:3: ruleNotifyContentUriSegment
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getSegmentsNotifyContentUriSegmentParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNotifyContentUriSegment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getSegmentsNotifyContentUriSegmentParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__SegmentsAssignment_1"


    // $ANTLR start "rule__NotifyContentUri__SegmentsAssignment_2_1"
    // InternalMickeyLang.g:15754:1: rule__NotifyContentUri__SegmentsAssignment_2_1 : ( ruleNotifyContentUriSegment ) ;
    public final void rule__NotifyContentUri__SegmentsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15758:1: ( ( ruleNotifyContentUriSegment ) )
            // InternalMickeyLang.g:15759:2: ( ruleNotifyContentUriSegment )
            {
            // InternalMickeyLang.g:15759:2: ( ruleNotifyContentUriSegment )
            // InternalMickeyLang.g:15760:3: ruleNotifyContentUriSegment
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriAccess().getSegmentsNotifyContentUriSegmentParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNotifyContentUriSegment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriAccess().getSegmentsNotifyContentUriSegmentParserRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUri__SegmentsAssignment_2_1"


    // $ANTLR start "rule__NotifyContentUriSegment__NameAssignment_0"
    // InternalMickeyLang.g:15769:1: rule__NotifyContentUriSegment__NameAssignment_0 : ( RULE_ID ) ;
    public final void rule__NotifyContentUriSegment__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15773:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15774:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15774:2: ( RULE_ID )
            // InternalMickeyLang.g:15775:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getNameIDTerminalRuleCall_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getNameIDTerminalRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__NameAssignment_0"


    // $ANTLR start "rule__NotifyContentUriSegment__NameAssignment_1_2"
    // InternalMickeyLang.g:15784:1: rule__NotifyContentUriSegment__NameAssignment_1_2 : ( RULE_ID ) ;
    public final void rule__NotifyContentUriSegment__NameAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15788:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15789:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15789:2: ( RULE_ID )
            // InternalMickeyLang.g:15790:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNotifyContentUriSegmentAccess().getNameIDTerminalRuleCall_1_2_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNotifyContentUriSegmentAccess().getNameIDTerminalRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NotifyContentUriSegment__NameAssignment_1_2"


    // $ANTLR start "rule__ContentUri__SegmentsAssignment_1"
    // InternalMickeyLang.g:15799:1: rule__ContentUri__SegmentsAssignment_1 : ( ruleContentUriSegment ) ;
    public final void rule__ContentUri__SegmentsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15803:1: ( ( ruleContentUriSegment ) )
            // InternalMickeyLang.g:15804:2: ( ruleContentUriSegment )
            {
            // InternalMickeyLang.g:15804:2: ( ruleContentUriSegment )
            // InternalMickeyLang.g:15805:3: ruleContentUriSegment
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getSegmentsContentUriSegmentParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleContentUriSegment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getSegmentsContentUriSegmentParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__SegmentsAssignment_1"


    // $ANTLR start "rule__ContentUri__SegmentsAssignment_2_1"
    // InternalMickeyLang.g:15814:1: rule__ContentUri__SegmentsAssignment_2_1 : ( ruleContentUriSegment ) ;
    public final void rule__ContentUri__SegmentsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15818:1: ( ( ruleContentUriSegment ) )
            // InternalMickeyLang.g:15819:2: ( ruleContentUriSegment )
            {
            // InternalMickeyLang.g:15819:2: ( ruleContentUriSegment )
            // InternalMickeyLang.g:15820:3: ruleContentUriSegment
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriAccess().getSegmentsContentUriSegmentParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleContentUriSegment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriAccess().getSegmentsContentUriSegmentParserRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUri__SegmentsAssignment_2_1"


    // $ANTLR start "rule__ContentUriQueryParam__LikeAssignment_1"
    // InternalMickeyLang.g:15829:1: rule__ContentUriQueryParam__LikeAssignment_1 : ( ( 'like' ) ) ;
    public final void rule__ContentUriQueryParam__LikeAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15833:1: ( ( ( 'like' ) ) )
            // InternalMickeyLang.g:15834:2: ( ( 'like' ) )
            {
            // InternalMickeyLang.g:15834:2: ( ( 'like' ) )
            // InternalMickeyLang.g:15835:3: ( 'like' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getLikeLikeKeyword_1_0()); 
            }
            // InternalMickeyLang.g:15836:3: ( 'like' )
            // InternalMickeyLang.g:15837:4: 'like'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getLikeLikeKeyword_1_0()); 
            }
            match(input,33,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getLikeLikeKeyword_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getLikeLikeKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__LikeAssignment_1"


    // $ANTLR start "rule__ContentUriQueryParam__ColumnAssignment_2"
    // InternalMickeyLang.g:15848:1: rule__ContentUriQueryParam__ColumnAssignment_2 : ( ( RULE_ID ) ) ;
    public final void rule__ContentUriQueryParam__ColumnAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15852:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:15853:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:15853:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15854:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getColumnColumnSourceCrossReference_2_0()); 
            }
            // InternalMickeyLang.g:15855:3: ( RULE_ID )
            // InternalMickeyLang.g:15856:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriQueryParamAccess().getColumnColumnSourceIDTerminalRuleCall_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getColumnColumnSourceIDTerminalRuleCall_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriQueryParamAccess().getColumnColumnSourceCrossReference_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriQueryParam__ColumnAssignment_2"


    // $ANTLR start "rule__ContentUriSegment__NameAssignment_0"
    // InternalMickeyLang.g:15867:1: rule__ContentUriSegment__NameAssignment_0 : ( RULE_ID ) ;
    public final void rule__ContentUriSegment__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15871:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15872:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15872:2: ( RULE_ID )
            // InternalMickeyLang.g:15873:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getNameIDTerminalRuleCall_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getNameIDTerminalRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__NameAssignment_0"


    // $ANTLR start "rule__ContentUriSegment__ParamAssignment_1_2"
    // InternalMickeyLang.g:15882:1: rule__ContentUriSegment__ParamAssignment_1_2 : ( ( RULE_ID ) ) ;
    public final void rule__ContentUriSegment__ParamAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15886:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:15887:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:15887:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15888:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getParamColumnSourceCrossReference_1_2_0()); 
            }
            // InternalMickeyLang.g:15889:3: ( RULE_ID )
            // InternalMickeyLang.g:15890:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getContentUriSegmentAccess().getParamColumnSourceIDTerminalRuleCall_1_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getParamColumnSourceIDTerminalRuleCall_1_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getContentUriSegmentAccess().getParamColumnSourceCrossReference_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ContentUriSegment__ParamAssignment_1_2"


    // $ANTLR start "rule__MigrationBlock__NameAssignment_2"
    // InternalMickeyLang.g:15901:1: rule__MigrationBlock__NameAssignment_2 : ( RULE_ID ) ;
    public final void rule__MigrationBlock__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15905:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:15906:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:15906:2: ( RULE_ID )
            // InternalMickeyLang.g:15907:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getNameIDTerminalRuleCall_2_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getNameIDTerminalRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__NameAssignment_2"


    // $ANTLR start "rule__MigrationBlock__FromAssignment_3_1"
    // InternalMickeyLang.g:15916:1: rule__MigrationBlock__FromAssignment_3_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__MigrationBlock__FromAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15920:1: ( ( ( ruleQualifiedName ) ) )
            // InternalMickeyLang.g:15921:2: ( ( ruleQualifiedName ) )
            {
            // InternalMickeyLang.g:15921:2: ( ( ruleQualifiedName ) )
            // InternalMickeyLang.g:15922:3: ( ruleQualifiedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getFromMigrationBlockCrossReference_3_1_0()); 
            }
            // InternalMickeyLang.g:15923:3: ( ruleQualifiedName )
            // InternalMickeyLang.g:15924:4: ruleQualifiedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getFromMigrationBlockQualifiedNameParserRuleCall_3_1_0_1()); 
            }
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getFromMigrationBlockQualifiedNameParserRuleCall_3_1_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getFromMigrationBlockCrossReference_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__FromAssignment_3_1"


    // $ANTLR start "rule__MigrationBlock__StatementsAssignment_5_0"
    // InternalMickeyLang.g:15935:1: rule__MigrationBlock__StatementsAssignment_5_0 : ( ruleDDLStatement ) ;
    public final void rule__MigrationBlock__StatementsAssignment_5_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15939:1: ( ( ruleDDLStatement ) )
            // InternalMickeyLang.g:15940:2: ( ruleDDLStatement )
            {
            // InternalMickeyLang.g:15940:2: ( ruleDDLStatement )
            // InternalMickeyLang.g:15941:3: ruleDDLStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMigrationBlockAccess().getStatementsDDLStatementParserRuleCall_5_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleDDLStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMigrationBlockAccess().getStatementsDDLStatementParserRuleCall_5_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MigrationBlock__StatementsAssignment_5_0"


    // $ANTLR start "rule__ExprConcat__OpAssignment_1_1"
    // InternalMickeyLang.g:15950:1: rule__ExprConcat__OpAssignment_1_1 : ( ( '||' ) ) ;
    public final void rule__ExprConcat__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15954:1: ( ( ( '||' ) ) )
            // InternalMickeyLang.g:15955:2: ( ( '||' ) )
            {
            // InternalMickeyLang.g:15955:2: ( ( '||' ) )
            // InternalMickeyLang.g:15956:3: ( '||' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getOpVerticalLineVerticalLineKeyword_1_1_0()); 
            }
            // InternalMickeyLang.g:15957:3: ( '||' )
            // InternalMickeyLang.g:15958:4: '||'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getOpVerticalLineVerticalLineKeyword_1_1_0()); 
            }
            match(input,118,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getOpVerticalLineVerticalLineKeyword_1_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getOpVerticalLineVerticalLineKeyword_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__OpAssignment_1_1"


    // $ANTLR start "rule__ExprConcat__RightAssignment_1_2"
    // InternalMickeyLang.g:15969:1: rule__ExprConcat__RightAssignment_1_2 : ( ruleExprMult ) ;
    public final void rule__ExprConcat__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15973:1: ( ( ruleExprMult ) )
            // InternalMickeyLang.g:15974:2: ( ruleExprMult )
            {
            // InternalMickeyLang.g:15974:2: ( ruleExprMult )
            // InternalMickeyLang.g:15975:3: ruleExprMult
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprConcatAccess().getRightExprMultParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprMult();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprConcatAccess().getRightExprMultParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprConcat__RightAssignment_1_2"


    // $ANTLR start "rule__ExprMult__OpAssignment_1_1"
    // InternalMickeyLang.g:15984:1: rule__ExprMult__OpAssignment_1_1 : ( ( rule__ExprMult__OpAlternatives_1_1_0 ) ) ;
    public final void rule__ExprMult__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:15988:1: ( ( ( rule__ExprMult__OpAlternatives_1_1_0 ) ) )
            // InternalMickeyLang.g:15989:2: ( ( rule__ExprMult__OpAlternatives_1_1_0 ) )
            {
            // InternalMickeyLang.g:15989:2: ( ( rule__ExprMult__OpAlternatives_1_1_0 ) )
            // InternalMickeyLang.g:15990:3: ( rule__ExprMult__OpAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getOpAlternatives_1_1_0()); 
            }
            // InternalMickeyLang.g:15991:3: ( rule__ExprMult__OpAlternatives_1_1_0 )
            // InternalMickeyLang.g:15991:4: rule__ExprMult__OpAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__ExprMult__OpAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getOpAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__OpAssignment_1_1"


    // $ANTLR start "rule__ExprMult__RightAssignment_1_2"
    // InternalMickeyLang.g:15999:1: rule__ExprMult__RightAssignment_1_2 : ( ruleExprAdd ) ;
    public final void rule__ExprMult__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16003:1: ( ( ruleExprAdd ) )
            // InternalMickeyLang.g:16004:2: ( ruleExprAdd )
            {
            // InternalMickeyLang.g:16004:2: ( ruleExprAdd )
            // InternalMickeyLang.g:16005:3: ruleExprAdd
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprMultAccess().getRightExprAddParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprAdd();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprMultAccess().getRightExprAddParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprMult__RightAssignment_1_2"


    // $ANTLR start "rule__ExprAdd__OpAssignment_1_1"
    // InternalMickeyLang.g:16014:1: rule__ExprAdd__OpAssignment_1_1 : ( ( rule__ExprAdd__OpAlternatives_1_1_0 ) ) ;
    public final void rule__ExprAdd__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16018:1: ( ( ( rule__ExprAdd__OpAlternatives_1_1_0 ) ) )
            // InternalMickeyLang.g:16019:2: ( ( rule__ExprAdd__OpAlternatives_1_1_0 ) )
            {
            // InternalMickeyLang.g:16019:2: ( ( rule__ExprAdd__OpAlternatives_1_1_0 ) )
            // InternalMickeyLang.g:16020:3: ( rule__ExprAdd__OpAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getOpAlternatives_1_1_0()); 
            }
            // InternalMickeyLang.g:16021:3: ( rule__ExprAdd__OpAlternatives_1_1_0 )
            // InternalMickeyLang.g:16021:4: rule__ExprAdd__OpAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__ExprAdd__OpAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getOpAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__OpAssignment_1_1"


    // $ANTLR start "rule__ExprAdd__RightAssignment_1_2"
    // InternalMickeyLang.g:16029:1: rule__ExprAdd__RightAssignment_1_2 : ( ruleExprBit ) ;
    public final void rule__ExprAdd__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16033:1: ( ( ruleExprBit ) )
            // InternalMickeyLang.g:16034:2: ( ruleExprBit )
            {
            // InternalMickeyLang.g:16034:2: ( ruleExprBit )
            // InternalMickeyLang.g:16035:3: ruleExprBit
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAddAccess().getRightExprBitParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprBit();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAddAccess().getRightExprBitParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAdd__RightAssignment_1_2"


    // $ANTLR start "rule__ExprBit__OpAssignment_1_1"
    // InternalMickeyLang.g:16044:1: rule__ExprBit__OpAssignment_1_1 : ( ( rule__ExprBit__OpAlternatives_1_1_0 ) ) ;
    public final void rule__ExprBit__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16048:1: ( ( ( rule__ExprBit__OpAlternatives_1_1_0 ) ) )
            // InternalMickeyLang.g:16049:2: ( ( rule__ExprBit__OpAlternatives_1_1_0 ) )
            {
            // InternalMickeyLang.g:16049:2: ( ( rule__ExprBit__OpAlternatives_1_1_0 ) )
            // InternalMickeyLang.g:16050:3: ( rule__ExprBit__OpAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getOpAlternatives_1_1_0()); 
            }
            // InternalMickeyLang.g:16051:3: ( rule__ExprBit__OpAlternatives_1_1_0 )
            // InternalMickeyLang.g:16051:4: rule__ExprBit__OpAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__ExprBit__OpAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getOpAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__OpAssignment_1_1"


    // $ANTLR start "rule__ExprBit__RightAssignment_1_2"
    // InternalMickeyLang.g:16059:1: rule__ExprBit__RightAssignment_1_2 : ( ruleExprRelate ) ;
    public final void rule__ExprBit__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16063:1: ( ( ruleExprRelate ) )
            // InternalMickeyLang.g:16064:2: ( ruleExprRelate )
            {
            // InternalMickeyLang.g:16064:2: ( ruleExprRelate )
            // InternalMickeyLang.g:16065:3: ruleExprRelate
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprBitAccess().getRightExprRelateParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprRelate();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprBitAccess().getRightExprRelateParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprBit__RightAssignment_1_2"


    // $ANTLR start "rule__ExprRelate__OpAssignment_1_1"
    // InternalMickeyLang.g:16074:1: rule__ExprRelate__OpAssignment_1_1 : ( ( rule__ExprRelate__OpAlternatives_1_1_0 ) ) ;
    public final void rule__ExprRelate__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16078:1: ( ( ( rule__ExprRelate__OpAlternatives_1_1_0 ) ) )
            // InternalMickeyLang.g:16079:2: ( ( rule__ExprRelate__OpAlternatives_1_1_0 ) )
            {
            // InternalMickeyLang.g:16079:2: ( ( rule__ExprRelate__OpAlternatives_1_1_0 ) )
            // InternalMickeyLang.g:16080:3: ( rule__ExprRelate__OpAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getOpAlternatives_1_1_0()); 
            }
            // InternalMickeyLang.g:16081:3: ( rule__ExprRelate__OpAlternatives_1_1_0 )
            // InternalMickeyLang.g:16081:4: rule__ExprRelate__OpAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__ExprRelate__OpAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getOpAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__OpAssignment_1_1"


    // $ANTLR start "rule__ExprRelate__RightAssignment_1_2"
    // InternalMickeyLang.g:16089:1: rule__ExprRelate__RightAssignment_1_2 : ( ruleExprEqual ) ;
    public final void rule__ExprRelate__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16093:1: ( ( ruleExprEqual ) )
            // InternalMickeyLang.g:16094:2: ( ruleExprEqual )
            {
            // InternalMickeyLang.g:16094:2: ( ruleExprEqual )
            // InternalMickeyLang.g:16095:3: ruleExprEqual
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprRelateAccess().getRightExprEqualParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprEqual();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprRelateAccess().getRightExprEqualParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprRelate__RightAssignment_1_2"


    // $ANTLR start "rule__ExprEqual__OpAssignment_1_1"
    // InternalMickeyLang.g:16104:1: rule__ExprEqual__OpAssignment_1_1 : ( ( rule__ExprEqual__OpAlternatives_1_1_0 ) ) ;
    public final void rule__ExprEqual__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16108:1: ( ( ( rule__ExprEqual__OpAlternatives_1_1_0 ) ) )
            // InternalMickeyLang.g:16109:2: ( ( rule__ExprEqual__OpAlternatives_1_1_0 ) )
            {
            // InternalMickeyLang.g:16109:2: ( ( rule__ExprEqual__OpAlternatives_1_1_0 ) )
            // InternalMickeyLang.g:16110:3: ( rule__ExprEqual__OpAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getOpAlternatives_1_1_0()); 
            }
            // InternalMickeyLang.g:16111:3: ( rule__ExprEqual__OpAlternatives_1_1_0 )
            // InternalMickeyLang.g:16111:4: rule__ExprEqual__OpAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__ExprEqual__OpAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getOpAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__OpAssignment_1_1"


    // $ANTLR start "rule__ExprEqual__RightAssignment_1_2"
    // InternalMickeyLang.g:16119:1: rule__ExprEqual__RightAssignment_1_2 : ( ruleExprAnd ) ;
    public final void rule__ExprEqual__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16123:1: ( ( ruleExprAnd ) )
            // InternalMickeyLang.g:16124:2: ( ruleExprAnd )
            {
            // InternalMickeyLang.g:16124:2: ( ruleExprAnd )
            // InternalMickeyLang.g:16125:3: ruleExprAnd
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprEqualAccess().getRightExprAndParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprAnd();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprEqualAccess().getRightExprAndParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprEqual__RightAssignment_1_2"


    // $ANTLR start "rule__ExprAnd__OpAssignment_1_1"
    // InternalMickeyLang.g:16134:1: rule__ExprAnd__OpAssignment_1_1 : ( ( 'and' ) ) ;
    public final void rule__ExprAnd__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16138:1: ( ( ( 'and' ) ) )
            // InternalMickeyLang.g:16139:2: ( ( 'and' ) )
            {
            // InternalMickeyLang.g:16139:2: ( ( 'and' ) )
            // InternalMickeyLang.g:16140:3: ( 'and' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getOpAndKeyword_1_1_0()); 
            }
            // InternalMickeyLang.g:16141:3: ( 'and' )
            // InternalMickeyLang.g:16142:4: 'and'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getOpAndKeyword_1_1_0()); 
            }
            match(input,119,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getOpAndKeyword_1_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getOpAndKeyword_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__OpAssignment_1_1"


    // $ANTLR start "rule__ExprAnd__RightAssignment_1_2"
    // InternalMickeyLang.g:16153:1: rule__ExprAnd__RightAssignment_1_2 : ( ruleExprOr ) ;
    public final void rule__ExprAnd__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16157:1: ( ( ruleExprOr ) )
            // InternalMickeyLang.g:16158:2: ( ruleExprOr )
            {
            // InternalMickeyLang.g:16158:2: ( ruleExprOr )
            // InternalMickeyLang.g:16159:3: ruleExprOr
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprAndAccess().getRightExprOrParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExprOr();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprAndAccess().getRightExprOrParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprAnd__RightAssignment_1_2"


    // $ANTLR start "rule__ExprOr__OpAssignment_1_1"
    // InternalMickeyLang.g:16168:1: rule__ExprOr__OpAssignment_1_1 : ( ( 'or' ) ) ;
    public final void rule__ExprOr__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16172:1: ( ( ( 'or' ) ) )
            // InternalMickeyLang.g:16173:2: ( ( 'or' ) )
            {
            // InternalMickeyLang.g:16173:2: ( ( 'or' ) )
            // InternalMickeyLang.g:16174:3: ( 'or' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getOpOrKeyword_1_1_0()); 
            }
            // InternalMickeyLang.g:16175:3: ( 'or' )
            // InternalMickeyLang.g:16176:4: 'or'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getOpOrKeyword_1_1_0()); 
            }
            match(input,114,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getOpOrKeyword_1_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getOpOrKeyword_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__OpAssignment_1_1"


    // $ANTLR start "rule__ExprOr__RightAssignment_1_2"
    // InternalMickeyLang.g:16187:1: rule__ExprOr__RightAssignment_1_2 : ( ruleNullCheckExpression ) ;
    public final void rule__ExprOr__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16191:1: ( ( ruleNullCheckExpression ) )
            // InternalMickeyLang.g:16192:2: ( ruleNullCheckExpression )
            {
            // InternalMickeyLang.g:16192:2: ( ruleNullCheckExpression )
            // InternalMickeyLang.g:16193:3: ruleNullCheckExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExprOrAccess().getRightNullCheckExpressionParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNullCheckExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExprOrAccess().getRightNullCheckExpressionParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExprOr__RightAssignment_1_2"


    // $ANTLR start "rule__NullCheckExpression__RightAssignment_1_1"
    // InternalMickeyLang.g:16202:1: rule__NullCheckExpression__RightAssignment_1_1 : ( ruleNullExpression ) ;
    public final void rule__NullCheckExpression__RightAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16206:1: ( ( ruleNullExpression ) )
            // InternalMickeyLang.g:16207:2: ( ruleNullExpression )
            {
            // InternalMickeyLang.g:16207:2: ( ruleNullExpression )
            // InternalMickeyLang.g:16208:3: ruleNullExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullCheckExpressionAccess().getRightNullExpressionParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNullExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullCheckExpressionAccess().getRightNullExpressionParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullCheckExpression__RightAssignment_1_1"


    // $ANTLR start "rule__PrimaryExpression__ColumnAssignment_0_2"
    // InternalMickeyLang.g:16217:1: rule__PrimaryExpression__ColumnAssignment_0_2 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__ColumnAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16221:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16222:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16222:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16223:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_0_2_0()); 
            }
            // InternalMickeyLang.g:16224:3: ( RULE_ID )
            // InternalMickeyLang.g:16225:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_0_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_0_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_0_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ColumnAssignment_0_2"


    // $ANTLR start "rule__PrimaryExpression__ColumnAssignment_1_2"
    // InternalMickeyLang.g:16236:1: rule__PrimaryExpression__ColumnAssignment_1_2 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__ColumnAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16240:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16241:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16241:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16242:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_1_2_0()); 
            }
            // InternalMickeyLang.g:16243:3: ( RULE_ID )
            // InternalMickeyLang.g:16244:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_1_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_1_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ColumnAssignment_1_2"


    // $ANTLR start "rule__PrimaryExpression__SourceAssignment_2_1_0_0"
    // InternalMickeyLang.g:16255:1: rule__PrimaryExpression__SourceAssignment_2_1_0_0 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__SourceAssignment_2_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16259:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16260:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16260:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16261:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceCrossReference_2_1_0_0_0()); 
            }
            // InternalMickeyLang.g:16262:3: ( RULE_ID )
            // InternalMickeyLang.g:16263:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceIDTerminalRuleCall_2_1_0_0_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceIDTerminalRuleCall_2_1_0_0_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceCrossReference_2_1_0_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__SourceAssignment_2_1_0_0"


    // $ANTLR start "rule__PrimaryExpression__SourceAssignment_2_1_1_0"
    // InternalMickeyLang.g:16274:1: rule__PrimaryExpression__SourceAssignment_2_1_1_0 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__SourceAssignment_2_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16278:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16279:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16279:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16280:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceCrossReference_2_1_1_0_0()); 
            }
            // InternalMickeyLang.g:16281:3: ( RULE_ID )
            // InternalMickeyLang.g:16282:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceIDTerminalRuleCall_2_1_1_0_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceIDTerminalRuleCall_2_1_1_0_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSourceSelectSourceCrossReference_2_1_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__SourceAssignment_2_1_1_0"


    // $ANTLR start "rule__PrimaryExpression__AllAssignment_2_1_1_2_0"
    // InternalMickeyLang.g:16293:1: rule__PrimaryExpression__AllAssignment_2_1_1_2_0 : ( ( '*' ) ) ;
    public final void rule__PrimaryExpression__AllAssignment_2_1_1_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16297:1: ( ( ( '*' ) ) )
            // InternalMickeyLang.g:16298:2: ( ( '*' ) )
            {
            // InternalMickeyLang.g:16298:2: ( ( '*' ) )
            // InternalMickeyLang.g:16299:3: ( '*' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_2_1_1_2_0_0()); 
            }
            // InternalMickeyLang.g:16300:3: ( '*' )
            // InternalMickeyLang.g:16301:4: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_2_1_1_2_0_0()); 
            }
            match(input,12,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_2_1_1_2_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_2_1_1_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__AllAssignment_2_1_1_2_0"


    // $ANTLR start "rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1"
    // InternalMickeyLang.g:16312:1: rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16316:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16317:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16317:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16318:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_2_1_1_2_1_0()); 
            }
            // InternalMickeyLang.g:16319:3: ( RULE_ID )
            // InternalMickeyLang.g:16320:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_2_1_1_2_1_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_2_1_1_2_1_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_2_1_1_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ColumnAssignment_2_1_1_2_1"


    // $ANTLR start "rule__PrimaryExpression__ColumnAssignment_2_1_2"
    // InternalMickeyLang.g:16331:1: rule__PrimaryExpression__ColumnAssignment_2_1_2 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__ColumnAssignment_2_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16335:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16336:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16336:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16337:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_2_1_2_0()); 
            }
            // InternalMickeyLang.g:16338:3: ( RULE_ID )
            // InternalMickeyLang.g:16339:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_2_1_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceIDTerminalRuleCall_2_1_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getColumnColumnSourceCrossReference_2_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ColumnAssignment_2_1_2"


    // $ANTLR start "rule__PrimaryExpression__LiteralValueAssignment_3_1"
    // InternalMickeyLang.g:16350:1: rule__PrimaryExpression__LiteralValueAssignment_3_1 : ( ruleLiteralValue ) ;
    public final void rule__PrimaryExpression__LiteralValueAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16354:1: ( ( ruleLiteralValue ) )
            // InternalMickeyLang.g:16355:2: ( ruleLiteralValue )
            {
            // InternalMickeyLang.g:16355:2: ( ruleLiteralValue )
            // InternalMickeyLang.g:16356:3: ruleLiteralValue
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getLiteralValueLiteralValueParserRuleCall_3_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleLiteralValue();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getLiteralValueLiteralValueParserRuleCall_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__LiteralValueAssignment_3_1"


    // $ANTLR start "rule__PrimaryExpression__ExpressionAssignment_4_2"
    // InternalMickeyLang.g:16365:1: rule__PrimaryExpression__ExpressionAssignment_4_2 : ( ruleSqlExpression ) ;
    public final void rule__PrimaryExpression__ExpressionAssignment_4_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16369:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16370:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16370:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16371:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExpressionSqlExpressionParserRuleCall_4_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExpressionSqlExpressionParserRuleCall_4_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ExpressionAssignment_4_2"


    // $ANTLR start "rule__PrimaryExpression__NotAssignment_5_1"
    // InternalMickeyLang.g:16380:1: rule__PrimaryExpression__NotAssignment_5_1 : ( ( 'not' ) ) ;
    public final void rule__PrimaryExpression__NotAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16384:1: ( ( ( 'not' ) ) )
            // InternalMickeyLang.g:16385:2: ( ( 'not' ) )
            {
            // InternalMickeyLang.g:16385:2: ( ( 'not' ) )
            // InternalMickeyLang.g:16386:3: ( 'not' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNotNotKeyword_5_1_0()); 
            }
            // InternalMickeyLang.g:16387:3: ( 'not' )
            // InternalMickeyLang.g:16388:4: 'not'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNotNotKeyword_5_1_0()); 
            }
            match(input,120,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNotNotKeyword_5_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNotNotKeyword_5_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__NotAssignment_5_1"


    // $ANTLR start "rule__PrimaryExpression__ExistsAssignment_5_2"
    // InternalMickeyLang.g:16399:1: rule__PrimaryExpression__ExistsAssignment_5_2 : ( ( 'exists' ) ) ;
    public final void rule__PrimaryExpression__ExistsAssignment_5_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16403:1: ( ( ( 'exists' ) ) )
            // InternalMickeyLang.g:16404:2: ( ( 'exists' ) )
            {
            // InternalMickeyLang.g:16404:2: ( ( 'exists' ) )
            // InternalMickeyLang.g:16405:3: ( 'exists' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExistsExistsKeyword_5_2_0()); 
            }
            // InternalMickeyLang.g:16406:3: ( 'exists' )
            // InternalMickeyLang.g:16407:4: 'exists'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExistsExistsKeyword_5_2_0()); 
            }
            match(input,121,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExistsExistsKeyword_5_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExistsExistsKeyword_5_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ExistsAssignment_5_2"


    // $ANTLR start "rule__PrimaryExpression__SelectAssignment_5_4"
    // InternalMickeyLang.g:16418:1: rule__PrimaryExpression__SelectAssignment_5_4 : ( ruleSelectStatement ) ;
    public final void rule__PrimaryExpression__SelectAssignment_5_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16422:1: ( ( ruleSelectStatement ) )
            // InternalMickeyLang.g:16423:2: ( ruleSelectStatement )
            {
            // InternalMickeyLang.g:16423:2: ( ruleSelectStatement )
            // InternalMickeyLang.g:16424:3: ruleSelectStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getSelectSelectStatementParserRuleCall_5_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getSelectSelectStatementParserRuleCall_5_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__SelectAssignment_5_4"


    // $ANTLR start "rule__PrimaryExpression__CaseExpressionAssignment_6_2"
    // InternalMickeyLang.g:16433:1: rule__PrimaryExpression__CaseExpressionAssignment_6_2 : ( ruleSqlExpression ) ;
    public final void rule__PrimaryExpression__CaseExpressionAssignment_6_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16437:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16438:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16438:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16439:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCaseExpressionSqlExpressionParserRuleCall_6_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCaseExpressionSqlExpressionParserRuleCall_6_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__CaseExpressionAssignment_6_2"


    // $ANTLR start "rule__PrimaryExpression__CasesAssignment_6_3"
    // InternalMickeyLang.g:16448:1: rule__PrimaryExpression__CasesAssignment_6_3 : ( ruleCase ) ;
    public final void rule__PrimaryExpression__CasesAssignment_6_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16452:1: ( ( ruleCase ) )
            // InternalMickeyLang.g:16453:2: ( ruleCase )
            {
            // InternalMickeyLang.g:16453:2: ( ruleCase )
            // InternalMickeyLang.g:16454:3: ruleCase
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_6_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleCase();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getCasesCaseParserRuleCall_6_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__CasesAssignment_6_3"


    // $ANTLR start "rule__PrimaryExpression__ElseExpressionAssignment_6_4_1"
    // InternalMickeyLang.g:16463:1: rule__PrimaryExpression__ElseExpressionAssignment_6_4_1 : ( ruleSqlExpression ) ;
    public final void rule__PrimaryExpression__ElseExpressionAssignment_6_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16467:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16468:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16468:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16469:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getElseExpressionSqlExpressionParserRuleCall_6_4_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getElseExpressionSqlExpressionParserRuleCall_6_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ElseExpressionAssignment_6_4_1"


    // $ANTLR start "rule__PrimaryExpression__NameAssignment_7_1"
    // InternalMickeyLang.g:16478:1: rule__PrimaryExpression__NameAssignment_7_1 : ( RULE_ID ) ;
    public final void rule__PrimaryExpression__NameAssignment_7_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16482:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16483:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:16483:2: ( RULE_ID )
            // InternalMickeyLang.g:16484:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getNameIDTerminalRuleCall_7_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getNameIDTerminalRuleCall_7_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__NameAssignment_7_1"


    // $ANTLR start "rule__PrimaryExpression__AllAssignment_7_3_0"
    // InternalMickeyLang.g:16493:1: rule__PrimaryExpression__AllAssignment_7_3_0 : ( ( '*' ) ) ;
    public final void rule__PrimaryExpression__AllAssignment_7_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16497:1: ( ( ( '*' ) ) )
            // InternalMickeyLang.g:16498:2: ( ( '*' ) )
            {
            // InternalMickeyLang.g:16498:2: ( ( '*' ) )
            // InternalMickeyLang.g:16499:3: ( '*' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_7_3_0_0()); 
            }
            // InternalMickeyLang.g:16500:3: ( '*' )
            // InternalMickeyLang.g:16501:4: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_7_3_0_0()); 
            }
            match(input,12,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_7_3_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getAllAsteriskKeyword_7_3_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__AllAssignment_7_3_0"


    // $ANTLR start "rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0"
    // InternalMickeyLang.g:16512:1: rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0 : ( ruleSqlExpression ) ;
    public final void rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16516:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16517:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16517:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16518:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgumentsSqlExpressionParserRuleCall_7_3_1_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgumentsSqlExpressionParserRuleCall_7_3_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ArgumentsAssignment_7_3_1_0"


    // $ANTLR start "rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1"
    // InternalMickeyLang.g:16527:1: rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1 : ( ruleSqlExpression ) ;
    public final void rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16531:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16532:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16532:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16533:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgumentsSqlExpressionParserRuleCall_7_3_1_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgumentsSqlExpressionParserRuleCall_7_3_1_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ArgumentsAssignment_7_3_1_1_1"


    // $ANTLR start "rule__PrimaryExpression__ExpressionAssignment_8_3"
    // InternalMickeyLang.g:16542:1: rule__PrimaryExpression__ExpressionAssignment_8_3 : ( ruleSqlExpression ) ;
    public final void rule__PrimaryExpression__ExpressionAssignment_8_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16546:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16547:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16547:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16548:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getExpressionSqlExpressionParserRuleCall_8_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getExpressionSqlExpressionParserRuleCall_8_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ExpressionAssignment_8_3"


    // $ANTLR start "rule__PrimaryExpression__TypeAssignment_8_5"
    // InternalMickeyLang.g:16557:1: rule__PrimaryExpression__TypeAssignment_8_5 : ( ruleSqliteDataType ) ;
    public final void rule__PrimaryExpression__TypeAssignment_8_5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16561:1: ( ( ruleSqliteDataType ) )
            // InternalMickeyLang.g:16562:2: ( ruleSqliteDataType )
            {
            // InternalMickeyLang.g:16562:2: ( ruleSqliteDataType )
            // InternalMickeyLang.g:16563:3: ruleSqliteDataType
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getTypeSqliteDataTypeEnumRuleCall_8_5_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqliteDataType();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getTypeSqliteDataTypeEnumRuleCall_8_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__TypeAssignment_8_5"


    // $ANTLR start "rule__PrimaryExpression__ArgAssignment_9_2"
    // InternalMickeyLang.g:16572:1: rule__PrimaryExpression__ArgAssignment_9_2 : ( ( RULE_ID ) ) ;
    public final void rule__PrimaryExpression__ArgAssignment_9_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16576:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:16577:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:16577:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:16578:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgFunctionArgCrossReference_9_2_0()); 
            }
            // InternalMickeyLang.g:16579:3: ( RULE_ID )
            // InternalMickeyLang.g:16580:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpressionAccess().getArgFunctionArgIDTerminalRuleCall_9_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgFunctionArgIDTerminalRuleCall_9_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpressionAccess().getArgFunctionArgCrossReference_9_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpression__ArgAssignment_9_2"


    // $ANTLR start "rule__Case__WhenExpressionAssignment_1"
    // InternalMickeyLang.g:16591:1: rule__Case__WhenExpressionAssignment_1 : ( ruleSqlExpression ) ;
    public final void rule__Case__WhenExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16595:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16596:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16596:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16597:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getWhenExpressionSqlExpressionParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getWhenExpressionSqlExpressionParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__WhenExpressionAssignment_1"


    // $ANTLR start "rule__Case__ThenExpressionAssignment_3"
    // InternalMickeyLang.g:16606:1: rule__Case__ThenExpressionAssignment_3 : ( ruleSqlExpression ) ;
    public final void rule__Case__ThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16610:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16611:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16611:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16612:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCaseAccess().getThenExpressionSqlExpressionParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCaseAccess().getThenExpressionSqlExpressionParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__ThenExpressionAssignment_3"


    // $ANTLR start "rule__SelectStatement__CoreAssignment_0"
    // InternalMickeyLang.g:16621:1: rule__SelectStatement__CoreAssignment_0 : ( ruleSelectCore ) ;
    public final void rule__SelectStatement__CoreAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16625:1: ( ( ruleSelectCore ) )
            // InternalMickeyLang.g:16626:2: ( ruleSelectCore )
            {
            // InternalMickeyLang.g:16626:2: ( ruleSelectCore )
            // InternalMickeyLang.g:16627:3: ruleSelectCore
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getCoreSelectCoreParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectCore();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getCoreSelectCoreParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__CoreAssignment_0"


    // $ANTLR start "rule__SelectStatement__OrderbyAssignment_1_1"
    // InternalMickeyLang.g:16636:1: rule__SelectStatement__OrderbyAssignment_1_1 : ( ruleOrderingTermList ) ;
    public final void rule__SelectStatement__OrderbyAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16640:1: ( ( ruleOrderingTermList ) )
            // InternalMickeyLang.g:16641:2: ( ruleOrderingTermList )
            {
            // InternalMickeyLang.g:16641:2: ( ruleOrderingTermList )
            // InternalMickeyLang.g:16642:3: ruleOrderingTermList
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getOrderbyOrderingTermListParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleOrderingTermList();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getOrderbyOrderingTermListParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__OrderbyAssignment_1_1"


    // $ANTLR start "rule__SelectStatement__LimitAssignment_2_1"
    // InternalMickeyLang.g:16651:1: rule__SelectStatement__LimitAssignment_2_1 : ( ruleSqlExpression ) ;
    public final void rule__SelectStatement__LimitAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16655:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16656:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16656:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16657:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getLimitSqlExpressionParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getLimitSqlExpressionParserRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__LimitAssignment_2_1"


    // $ANTLR start "rule__SelectStatement__LimitOffsetAssignment_2_2_1"
    // InternalMickeyLang.g:16666:1: rule__SelectStatement__LimitOffsetAssignment_2_2_1 : ( ruleSqlExpression ) ;
    public final void rule__SelectStatement__LimitOffsetAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16670:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16671:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16671:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16672:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectStatementAccess().getLimitOffsetSqlExpressionParserRuleCall_2_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectStatementAccess().getLimitOffsetSqlExpressionParserRuleCall_2_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectStatement__LimitOffsetAssignment_2_2_1"


    // $ANTLR start "rule__OrderingTermList__OrderingTermsAssignment_0"
    // InternalMickeyLang.g:16681:1: rule__OrderingTermList__OrderingTermsAssignment_0 : ( ruleOrderingTerm ) ;
    public final void rule__OrderingTermList__OrderingTermsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16685:1: ( ( ruleOrderingTerm ) )
            // InternalMickeyLang.g:16686:2: ( ruleOrderingTerm )
            {
            // InternalMickeyLang.g:16686:2: ( ruleOrderingTerm )
            // InternalMickeyLang.g:16687:3: ruleOrderingTerm
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getOrderingTermsOrderingTermParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleOrderingTerm();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getOrderingTermsOrderingTermParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__OrderingTermsAssignment_0"


    // $ANTLR start "rule__OrderingTermList__OrderingTermsAssignment_1_1"
    // InternalMickeyLang.g:16696:1: rule__OrderingTermList__OrderingTermsAssignment_1_1 : ( ruleOrderingTerm ) ;
    public final void rule__OrderingTermList__OrderingTermsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16700:1: ( ( ruleOrderingTerm ) )
            // InternalMickeyLang.g:16701:2: ( ruleOrderingTerm )
            {
            // InternalMickeyLang.g:16701:2: ( ruleOrderingTerm )
            // InternalMickeyLang.g:16702:3: ruleOrderingTerm
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermListAccess().getOrderingTermsOrderingTermParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleOrderingTerm();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermListAccess().getOrderingTermsOrderingTermParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTermList__OrderingTermsAssignment_1_1"


    // $ANTLR start "rule__SelectCore__OpAssignment_1_1"
    // InternalMickeyLang.g:16711:1: rule__SelectCore__OpAssignment_1_1 : ( ruleCompoundOperator ) ;
    public final void rule__SelectCore__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16715:1: ( ( ruleCompoundOperator ) )
            // InternalMickeyLang.g:16716:2: ( ruleCompoundOperator )
            {
            // InternalMickeyLang.g:16716:2: ( ruleCompoundOperator )
            // InternalMickeyLang.g:16717:3: ruleCompoundOperator
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getOpCompoundOperatorEnumRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleCompoundOperator();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getOpCompoundOperatorEnumRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__OpAssignment_1_1"


    // $ANTLR start "rule__SelectCore__RightAssignment_1_2"
    // InternalMickeyLang.g:16726:1: rule__SelectCore__RightAssignment_1_2 : ( ruleSelectExpression ) ;
    public final void rule__SelectCore__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16730:1: ( ( ruleSelectExpression ) )
            // InternalMickeyLang.g:16731:2: ( ruleSelectExpression )
            {
            // InternalMickeyLang.g:16731:2: ( ruleSelectExpression )
            // InternalMickeyLang.g:16732:3: ruleSelectExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectCoreAccess().getRightSelectExpressionParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectCoreAccess().getRightSelectExpressionParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectCore__RightAssignment_1_2"


    // $ANTLR start "rule__SelectExpression__DistinctAssignment_2_0"
    // InternalMickeyLang.g:16741:1: rule__SelectExpression__DistinctAssignment_2_0 : ( ( 'distinct' ) ) ;
    public final void rule__SelectExpression__DistinctAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16745:1: ( ( ( 'distinct' ) ) )
            // InternalMickeyLang.g:16746:2: ( ( 'distinct' ) )
            {
            // InternalMickeyLang.g:16746:2: ( ( 'distinct' ) )
            // InternalMickeyLang.g:16747:3: ( 'distinct' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getDistinctDistinctKeyword_2_0_0()); 
            }
            // InternalMickeyLang.g:16748:3: ( 'distinct' )
            // InternalMickeyLang.g:16749:4: 'distinct'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getDistinctDistinctKeyword_2_0_0()); 
            }
            match(input,122,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getDistinctDistinctKeyword_2_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getDistinctDistinctKeyword_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__DistinctAssignment_2_0"


    // $ANTLR start "rule__SelectExpression__AllAssignment_2_1"
    // InternalMickeyLang.g:16760:1: rule__SelectExpression__AllAssignment_2_1 : ( ( 'all' ) ) ;
    public final void rule__SelectExpression__AllAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16764:1: ( ( ( 'all' ) ) )
            // InternalMickeyLang.g:16765:2: ( ( 'all' ) )
            {
            // InternalMickeyLang.g:16765:2: ( ( 'all' ) )
            // InternalMickeyLang.g:16766:3: ( 'all' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getAllAllKeyword_2_1_0()); 
            }
            // InternalMickeyLang.g:16767:3: ( 'all' )
            // InternalMickeyLang.g:16768:4: 'all'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getAllAllKeyword_2_1_0()); 
            }
            match(input,123,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getAllAllKeyword_2_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getAllAllKeyword_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__AllAssignment_2_1"


    // $ANTLR start "rule__SelectExpression__AllColumnsAssignment_3_0"
    // InternalMickeyLang.g:16779:1: rule__SelectExpression__AllColumnsAssignment_3_0 : ( ( '*' ) ) ;
    public final void rule__SelectExpression__AllColumnsAssignment_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16783:1: ( ( ( '*' ) ) )
            // InternalMickeyLang.g:16784:2: ( ( '*' ) )
            {
            // InternalMickeyLang.g:16784:2: ( ( '*' ) )
            // InternalMickeyLang.g:16785:3: ( '*' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getAllColumnsAsteriskKeyword_3_0_0()); 
            }
            // InternalMickeyLang.g:16786:3: ( '*' )
            // InternalMickeyLang.g:16787:4: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getAllColumnsAsteriskKeyword_3_0_0()); 
            }
            match(input,12,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getAllColumnsAsteriskKeyword_3_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getAllColumnsAsteriskKeyword_3_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__AllColumnsAssignment_3_0"


    // $ANTLR start "rule__SelectExpression__SelectListAssignment_3_1"
    // InternalMickeyLang.g:16798:1: rule__SelectExpression__SelectListAssignment_3_1 : ( ruleSelectList ) ;
    public final void rule__SelectExpression__SelectListAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16802:1: ( ( ruleSelectList ) )
            // InternalMickeyLang.g:16803:2: ( ruleSelectList )
            {
            // InternalMickeyLang.g:16803:2: ( ruleSelectList )
            // InternalMickeyLang.g:16804:3: ruleSelectList
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getSelectListSelectListParserRuleCall_3_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectList();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getSelectListSelectListParserRuleCall_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__SelectListAssignment_3_1"


    // $ANTLR start "rule__SelectExpression__SourceAssignment_4_1"
    // InternalMickeyLang.g:16813:1: rule__SelectExpression__SourceAssignment_4_1 : ( ruleJoinSource ) ;
    public final void rule__SelectExpression__SourceAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16817:1: ( ( ruleJoinSource ) )
            // InternalMickeyLang.g:16818:2: ( ruleJoinSource )
            {
            // InternalMickeyLang.g:16818:2: ( ruleJoinSource )
            // InternalMickeyLang.g:16819:3: ruleJoinSource
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getSourceJoinSourceParserRuleCall_4_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleJoinSource();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getSourceJoinSourceParserRuleCall_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__SourceAssignment_4_1"


    // $ANTLR start "rule__SelectExpression__WhereAssignment_5_1"
    // InternalMickeyLang.g:16828:1: rule__SelectExpression__WhereAssignment_5_1 : ( ruleWhereExpressions ) ;
    public final void rule__SelectExpression__WhereAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16832:1: ( ( ruleWhereExpressions ) )
            // InternalMickeyLang.g:16833:2: ( ruleWhereExpressions )
            {
            // InternalMickeyLang.g:16833:2: ( ruleWhereExpressions )
            // InternalMickeyLang.g:16834:3: ruleWhereExpressions
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getWhereWhereExpressionsParserRuleCall_5_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleWhereExpressions();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getWhereWhereExpressionsParserRuleCall_5_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__WhereAssignment_5_1"


    // $ANTLR start "rule__SelectExpression__GroupByAssignment_6_1"
    // InternalMickeyLang.g:16843:1: rule__SelectExpression__GroupByAssignment_6_1 : ( ruleGroupByExpressions ) ;
    public final void rule__SelectExpression__GroupByAssignment_6_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16847:1: ( ( ruleGroupByExpressions ) )
            // InternalMickeyLang.g:16848:2: ( ruleGroupByExpressions )
            {
            // InternalMickeyLang.g:16848:2: ( ruleGroupByExpressions )
            // InternalMickeyLang.g:16849:3: ruleGroupByExpressions
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getGroupByGroupByExpressionsParserRuleCall_6_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleGroupByExpressions();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getGroupByGroupByExpressionsParserRuleCall_6_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__GroupByAssignment_6_1"


    // $ANTLR start "rule__SelectExpression__HavingAssignment_7_1"
    // InternalMickeyLang.g:16858:1: rule__SelectExpression__HavingAssignment_7_1 : ( ruleHavingExpressions ) ;
    public final void rule__SelectExpression__HavingAssignment_7_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16862:1: ( ( ruleHavingExpressions ) )
            // InternalMickeyLang.g:16863:2: ( ruleHavingExpressions )
            {
            // InternalMickeyLang.g:16863:2: ( ruleHavingExpressions )
            // InternalMickeyLang.g:16864:3: ruleHavingExpressions
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectExpressionAccess().getHavingHavingExpressionsParserRuleCall_7_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleHavingExpressions();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectExpressionAccess().getHavingHavingExpressionsParserRuleCall_7_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectExpression__HavingAssignment_7_1"


    // $ANTLR start "rule__SelectList__ResultColumnsAssignment_0"
    // InternalMickeyLang.g:16873:1: rule__SelectList__ResultColumnsAssignment_0 : ( ruleResultColumn ) ;
    public final void rule__SelectList__ResultColumnsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16877:1: ( ( ruleResultColumn ) )
            // InternalMickeyLang.g:16878:2: ( ruleResultColumn )
            {
            // InternalMickeyLang.g:16878:2: ( ruleResultColumn )
            // InternalMickeyLang.g:16879:3: ruleResultColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getResultColumnsResultColumnParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleResultColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getResultColumnsResultColumnParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__ResultColumnsAssignment_0"


    // $ANTLR start "rule__SelectList__ResultColumnsAssignment_1_1"
    // InternalMickeyLang.g:16888:1: rule__SelectList__ResultColumnsAssignment_1_1 : ( ruleResultColumn ) ;
    public final void rule__SelectList__ResultColumnsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16892:1: ( ( ruleResultColumn ) )
            // InternalMickeyLang.g:16893:2: ( ruleResultColumn )
            {
            // InternalMickeyLang.g:16893:2: ( ruleResultColumn )
            // InternalMickeyLang.g:16894:3: ruleResultColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelectListAccess().getResultColumnsResultColumnParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleResultColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelectListAccess().getResultColumnsResultColumnParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelectList__ResultColumnsAssignment_1_1"


    // $ANTLR start "rule__WhereExpressions__ExpressionAssignment"
    // InternalMickeyLang.g:16903:1: rule__WhereExpressions__ExpressionAssignment : ( ruleSqlExpression ) ;
    public final void rule__WhereExpressions__ExpressionAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16907:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16908:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16908:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16909:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWhereExpressionsAccess().getExpressionSqlExpressionParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWhereExpressionsAccess().getExpressionSqlExpressionParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WhereExpressions__ExpressionAssignment"


    // $ANTLR start "rule__GroupByExpressions__GroupByExpressionsAssignment_0"
    // InternalMickeyLang.g:16918:1: rule__GroupByExpressions__GroupByExpressionsAssignment_0 : ( ruleSqlExpression ) ;
    public final void rule__GroupByExpressions__GroupByExpressionsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16922:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16923:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16923:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16924:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsSqlExpressionParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsSqlExpressionParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__GroupByExpressionsAssignment_0"


    // $ANTLR start "rule__GroupByExpressions__GroupByExpressionsAssignment_1_1"
    // InternalMickeyLang.g:16933:1: rule__GroupByExpressions__GroupByExpressionsAssignment_1_1 : ( ruleSqlExpression ) ;
    public final void rule__GroupByExpressions__GroupByExpressionsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16937:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16938:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16938:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16939:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsSqlExpressionParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getGroupByExpressionsAccess().getGroupByExpressionsSqlExpressionParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__GroupByExpressions__GroupByExpressionsAssignment_1_1"


    // $ANTLR start "rule__HavingExpressions__ExpressionAssignment"
    // InternalMickeyLang.g:16948:1: rule__HavingExpressions__ExpressionAssignment : ( ruleSqlExpression ) ;
    public final void rule__HavingExpressions__ExpressionAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16952:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16953:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16953:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16954:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getHavingExpressionsAccess().getExpressionSqlExpressionParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getHavingExpressionsAccess().getExpressionSqlExpressionParserRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__HavingExpressions__ExpressionAssignment"


    // $ANTLR start "rule__OrderingTerm__ExpressionAssignment_0"
    // InternalMickeyLang.g:16963:1: rule__OrderingTerm__ExpressionAssignment_0 : ( ruleSqlExpression ) ;
    public final void rule__OrderingTerm__ExpressionAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16967:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:16968:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:16968:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:16969:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getExpressionSqlExpressionParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getExpressionSqlExpressionParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__ExpressionAssignment_0"


    // $ANTLR start "rule__OrderingTerm__AscAssignment_1_0"
    // InternalMickeyLang.g:16978:1: rule__OrderingTerm__AscAssignment_1_0 : ( ( 'asc' ) ) ;
    public final void rule__OrderingTerm__AscAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:16982:1: ( ( ( 'asc' ) ) )
            // InternalMickeyLang.g:16983:2: ( ( 'asc' ) )
            {
            // InternalMickeyLang.g:16983:2: ( ( 'asc' ) )
            // InternalMickeyLang.g:16984:3: ( 'asc' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getAscAscKeyword_1_0_0()); 
            }
            // InternalMickeyLang.g:16985:3: ( 'asc' )
            // InternalMickeyLang.g:16986:4: 'asc'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getAscAscKeyword_1_0_0()); 
            }
            match(input,124,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getAscAscKeyword_1_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getAscAscKeyword_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__AscAssignment_1_0"


    // $ANTLR start "rule__OrderingTerm__DescAssignment_1_1"
    // InternalMickeyLang.g:16997:1: rule__OrderingTerm__DescAssignment_1_1 : ( ( 'desc' ) ) ;
    public final void rule__OrderingTerm__DescAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17001:1: ( ( ( 'desc' ) ) )
            // InternalMickeyLang.g:17002:2: ( ( 'desc' ) )
            {
            // InternalMickeyLang.g:17002:2: ( ( 'desc' ) )
            // InternalMickeyLang.g:17003:3: ( 'desc' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getDescDescKeyword_1_1_0()); 
            }
            // InternalMickeyLang.g:17004:3: ( 'desc' )
            // InternalMickeyLang.g:17005:4: 'desc'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOrderingTermAccess().getDescDescKeyword_1_1_0()); 
            }
            match(input,125,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getDescDescKeyword_1_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOrderingTermAccess().getDescDescKeyword_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OrderingTerm__DescAssignment_1_1"


    // $ANTLR start "rule__JoinSource__SourceAssignment_0"
    // InternalMickeyLang.g:17016:1: rule__JoinSource__SourceAssignment_0 : ( ruleSingleSource ) ;
    public final void rule__JoinSource__SourceAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17020:1: ( ( ruleSingleSource ) )
            // InternalMickeyLang.g:17021:2: ( ruleSingleSource )
            {
            // InternalMickeyLang.g:17021:2: ( ruleSingleSource )
            // InternalMickeyLang.g:17022:3: ruleSingleSource
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinSourceAccess().getSourceSingleSourceParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSingleSource();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinSourceAccess().getSourceSingleSourceParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinSource__SourceAssignment_0"


    // $ANTLR start "rule__JoinSource__JoinStatementsAssignment_1"
    // InternalMickeyLang.g:17031:1: rule__JoinSource__JoinStatementsAssignment_1 : ( ruleJoinStatement ) ;
    public final void rule__JoinSource__JoinStatementsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17035:1: ( ( ruleJoinStatement ) )
            // InternalMickeyLang.g:17036:2: ( ruleJoinStatement )
            {
            // InternalMickeyLang.g:17036:2: ( ruleJoinStatement )
            // InternalMickeyLang.g:17037:3: ruleJoinStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinSourceAccess().getJoinStatementsJoinStatementParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleJoinStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinSourceAccess().getJoinStatementsJoinStatementParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinSource__JoinStatementsAssignment_1"


    // $ANTLR start "rule__SingleSourceTable__TableReferenceAssignment_1"
    // InternalMickeyLang.g:17046:1: rule__SingleSourceTable__TableReferenceAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__SingleSourceTable__TableReferenceAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17050:1: ( ( ( ruleQualifiedName ) ) )
            // InternalMickeyLang.g:17051:2: ( ( ruleQualifiedName ) )
            {
            // InternalMickeyLang.g:17051:2: ( ( ruleQualifiedName ) )
            // InternalMickeyLang.g:17052:3: ( ruleQualifiedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getTableReferenceTableDefinitionCrossReference_1_0()); 
            }
            // InternalMickeyLang.g:17053:3: ( ruleQualifiedName )
            // InternalMickeyLang.g:17054:4: ruleQualifiedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getTableReferenceTableDefinitionQualifiedNameParserRuleCall_1_0_1()); 
            }
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getTableReferenceTableDefinitionQualifiedNameParserRuleCall_1_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getTableReferenceTableDefinitionCrossReference_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__TableReferenceAssignment_1"


    // $ANTLR start "rule__SingleSourceTable__NameAssignment_2_1"
    // InternalMickeyLang.g:17065:1: rule__SingleSourceTable__NameAssignment_2_1 : ( RULE_ID ) ;
    public final void rule__SingleSourceTable__NameAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17069:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17070:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17070:2: ( RULE_ID )
            // InternalMickeyLang.g:17071:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceTableAccess().getNameIDTerminalRuleCall_2_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceTableAccess().getNameIDTerminalRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceTable__NameAssignment_2_1"


    // $ANTLR start "rule__SingleSourceSelectStatement__SelectStatementAssignment_2"
    // InternalMickeyLang.g:17080:1: rule__SingleSourceSelectStatement__SelectStatementAssignment_2 : ( ruleSelectStatement ) ;
    public final void rule__SingleSourceSelectStatement__SelectStatementAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17084:1: ( ( ruleSelectStatement ) )
            // InternalMickeyLang.g:17085:2: ( ruleSelectStatement )
            {
            // InternalMickeyLang.g:17085:2: ( ruleSelectStatement )
            // InternalMickeyLang.g:17086:3: ruleSelectStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getSelectStatementSelectStatementParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getSelectStatementSelectStatementParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__SelectStatementAssignment_2"


    // $ANTLR start "rule__SingleSourceSelectStatement__NameAssignment_4_1"
    // InternalMickeyLang.g:17095:1: rule__SingleSourceSelectStatement__NameAssignment_4_1 : ( RULE_ID ) ;
    public final void rule__SingleSourceSelectStatement__NameAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17099:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17100:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17100:2: ( RULE_ID )
            // InternalMickeyLang.g:17101:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceSelectStatementAccess().getNameIDTerminalRuleCall_4_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceSelectStatementAccess().getNameIDTerminalRuleCall_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceSelectStatement__NameAssignment_4_1"


    // $ANTLR start "rule__SingleSourceJoin__JoinSourceAssignment_1"
    // InternalMickeyLang.g:17110:1: rule__SingleSourceJoin__JoinSourceAssignment_1 : ( ruleJoinSource ) ;
    public final void rule__SingleSourceJoin__JoinSourceAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17114:1: ( ( ruleJoinSource ) )
            // InternalMickeyLang.g:17115:2: ( ruleJoinSource )
            {
            // InternalMickeyLang.g:17115:2: ( ruleJoinSource )
            // InternalMickeyLang.g:17116:3: ruleJoinSource
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSingleSourceJoinAccess().getJoinSourceJoinSourceParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleJoinSource();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSingleSourceJoinAccess().getJoinSourceJoinSourceParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SingleSourceJoin__JoinSourceAssignment_1"


    // $ANTLR start "rule__JoinStatement__NaturalAssignment_1"
    // InternalMickeyLang.g:17125:1: rule__JoinStatement__NaturalAssignment_1 : ( ( 'natural' ) ) ;
    public final void rule__JoinStatement__NaturalAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17129:1: ( ( ( 'natural' ) ) )
            // InternalMickeyLang.g:17130:2: ( ( 'natural' ) )
            {
            // InternalMickeyLang.g:17130:2: ( ( 'natural' ) )
            // InternalMickeyLang.g:17131:3: ( 'natural' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getNaturalNaturalKeyword_1_0()); 
            }
            // InternalMickeyLang.g:17132:3: ( 'natural' )
            // InternalMickeyLang.g:17133:4: 'natural'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getNaturalNaturalKeyword_1_0()); 
            }
            match(input,126,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getNaturalNaturalKeyword_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getNaturalNaturalKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__NaturalAssignment_1"


    // $ANTLR start "rule__JoinStatement__LeftAssignment_2_0_0"
    // InternalMickeyLang.g:17144:1: rule__JoinStatement__LeftAssignment_2_0_0 : ( ( 'left' ) ) ;
    public final void rule__JoinStatement__LeftAssignment_2_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17148:1: ( ( ( 'left' ) ) )
            // InternalMickeyLang.g:17149:2: ( ( 'left' ) )
            {
            // InternalMickeyLang.g:17149:2: ( ( 'left' ) )
            // InternalMickeyLang.g:17150:3: ( 'left' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getLeftLeftKeyword_2_0_0_0()); 
            }
            // InternalMickeyLang.g:17151:3: ( 'left' )
            // InternalMickeyLang.g:17152:4: 'left'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getLeftLeftKeyword_2_0_0_0()); 
            }
            match(input,127,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getLeftLeftKeyword_2_0_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getLeftLeftKeyword_2_0_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__LeftAssignment_2_0_0"


    // $ANTLR start "rule__JoinStatement__OuterAssignment_2_0_1"
    // InternalMickeyLang.g:17163:1: rule__JoinStatement__OuterAssignment_2_0_1 : ( ( 'outer' ) ) ;
    public final void rule__JoinStatement__OuterAssignment_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17167:1: ( ( ( 'outer' ) ) )
            // InternalMickeyLang.g:17168:2: ( ( 'outer' ) )
            {
            // InternalMickeyLang.g:17168:2: ( ( 'outer' ) )
            // InternalMickeyLang.g:17169:3: ( 'outer' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getOuterOuterKeyword_2_0_1_0()); 
            }
            // InternalMickeyLang.g:17170:3: ( 'outer' )
            // InternalMickeyLang.g:17171:4: 'outer'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getOuterOuterKeyword_2_0_1_0()); 
            }
            match(input,128,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getOuterOuterKeyword_2_0_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getOuterOuterKeyword_2_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__OuterAssignment_2_0_1"


    // $ANTLR start "rule__JoinStatement__InnerAssignment_2_1"
    // InternalMickeyLang.g:17182:1: rule__JoinStatement__InnerAssignment_2_1 : ( ( 'inner' ) ) ;
    public final void rule__JoinStatement__InnerAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17186:1: ( ( ( 'inner' ) ) )
            // InternalMickeyLang.g:17187:2: ( ( 'inner' ) )
            {
            // InternalMickeyLang.g:17187:2: ( ( 'inner' ) )
            // InternalMickeyLang.g:17188:3: ( 'inner' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getInnerInnerKeyword_2_1_0()); 
            }
            // InternalMickeyLang.g:17189:3: ( 'inner' )
            // InternalMickeyLang.g:17190:4: 'inner'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getInnerInnerKeyword_2_1_0()); 
            }
            match(input,129,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getInnerInnerKeyword_2_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getInnerInnerKeyword_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__InnerAssignment_2_1"


    // $ANTLR start "rule__JoinStatement__CrossAssignment_2_2"
    // InternalMickeyLang.g:17201:1: rule__JoinStatement__CrossAssignment_2_2 : ( ( 'cross' ) ) ;
    public final void rule__JoinStatement__CrossAssignment_2_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17205:1: ( ( ( 'cross' ) ) )
            // InternalMickeyLang.g:17206:2: ( ( 'cross' ) )
            {
            // InternalMickeyLang.g:17206:2: ( ( 'cross' ) )
            // InternalMickeyLang.g:17207:3: ( 'cross' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getCrossCrossKeyword_2_2_0()); 
            }
            // InternalMickeyLang.g:17208:3: ( 'cross' )
            // InternalMickeyLang.g:17209:4: 'cross'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getCrossCrossKeyword_2_2_0()); 
            }
            match(input,130,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getCrossCrossKeyword_2_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getCrossCrossKeyword_2_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__CrossAssignment_2_2"


    // $ANTLR start "rule__JoinStatement__SingleSourceAssignment_4"
    // InternalMickeyLang.g:17220:1: rule__JoinStatement__SingleSourceAssignment_4 : ( ruleSingleSource ) ;
    public final void rule__JoinStatement__SingleSourceAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17224:1: ( ( ruleSingleSource ) )
            // InternalMickeyLang.g:17225:2: ( ruleSingleSource )
            {
            // InternalMickeyLang.g:17225:2: ( ruleSingleSource )
            // InternalMickeyLang.g:17226:3: ruleSingleSource
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getSingleSourceSingleSourceParserRuleCall_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSingleSource();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getSingleSourceSingleSourceParserRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__SingleSourceAssignment_4"


    // $ANTLR start "rule__JoinStatement__ExpressionAssignment_6"
    // InternalMickeyLang.g:17235:1: rule__JoinStatement__ExpressionAssignment_6 : ( ruleSqlExpression ) ;
    public final void rule__JoinStatement__ExpressionAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17239:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:17240:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:17240:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:17241:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJoinStatementAccess().getExpressionSqlExpressionParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getJoinStatementAccess().getExpressionSqlExpressionParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__JoinStatement__ExpressionAssignment_6"


    // $ANTLR start "rule__ResultColumn__ExpressionAssignment_1"
    // InternalMickeyLang.g:17250:1: rule__ResultColumn__ExpressionAssignment_1 : ( ruleSqlExpression ) ;
    public final void rule__ResultColumn__ExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17254:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:17255:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:17255:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:17256:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getExpressionSqlExpressionParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getExpressionSqlExpressionParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__ExpressionAssignment_1"


    // $ANTLR start "rule__ResultColumn__NameAssignment_2_1"
    // InternalMickeyLang.g:17265:1: rule__ResultColumn__NameAssignment_2_1 : ( RULE_ID ) ;
    public final void rule__ResultColumn__NameAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17269:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17270:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17270:2: ( RULE_ID )
            // InternalMickeyLang.g:17271:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getResultColumnAccess().getNameIDTerminalRuleCall_2_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getResultColumnAccess().getNameIDTerminalRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ResultColumn__NameAssignment_2_1"


    // $ANTLR start "rule__LiteralValue__NumberAssignment_0_1"
    // InternalMickeyLang.g:17280:1: rule__LiteralValue__NumberAssignment_0_1 : ( ruleSignedNumber ) ;
    public final void rule__LiteralValue__NumberAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17284:1: ( ( ruleSignedNumber ) )
            // InternalMickeyLang.g:17285:2: ( ruleSignedNumber )
            {
            // InternalMickeyLang.g:17285:2: ( ruleSignedNumber )
            // InternalMickeyLang.g:17286:3: ruleSignedNumber
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getNumberSignedNumberParserRuleCall_0_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSignedNumber();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getNumberSignedNumberParserRuleCall_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__NumberAssignment_0_1"


    // $ANTLR start "rule__LiteralValue__LiteralAssignment_1_1"
    // InternalMickeyLang.g:17295:1: rule__LiteralValue__LiteralAssignment_1_1 : ( RULE_STRING ) ;
    public final void rule__LiteralValue__LiteralAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17299:1: ( ( RULE_STRING ) )
            // InternalMickeyLang.g:17300:2: ( RULE_STRING )
            {
            // InternalMickeyLang.g:17300:2: ( RULE_STRING )
            // InternalMickeyLang.g:17301:3: RULE_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralSTRINGTerminalRuleCall_1_1_0()); 
            }
            match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralSTRINGTerminalRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__LiteralAssignment_1_1"


    // $ANTLR start "rule__LiteralValue__LiteralAssignment_2_1"
    // InternalMickeyLang.g:17310:1: rule__LiteralValue__LiteralAssignment_2_1 : ( ( 'null' ) ) ;
    public final void rule__LiteralValue__LiteralAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17314:1: ( ( ( 'null' ) ) )
            // InternalMickeyLang.g:17315:2: ( ( 'null' ) )
            {
            // InternalMickeyLang.g:17315:2: ( ( 'null' ) )
            // InternalMickeyLang.g:17316:3: ( 'null' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralNullKeyword_2_1_0()); 
            }
            // InternalMickeyLang.g:17317:3: ( 'null' )
            // InternalMickeyLang.g:17318:4: 'null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralNullKeyword_2_1_0()); 
            }
            match(input,131,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralNullKeyword_2_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralNullKeyword_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__LiteralAssignment_2_1"


    // $ANTLR start "rule__LiteralValue__LiteralAssignment_3_1"
    // InternalMickeyLang.g:17329:1: rule__LiteralValue__LiteralAssignment_3_1 : ( ( 'current_time' ) ) ;
    public final void rule__LiteralValue__LiteralAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17333:1: ( ( ( 'current_time' ) ) )
            // InternalMickeyLang.g:17334:2: ( ( 'current_time' ) )
            {
            // InternalMickeyLang.g:17334:2: ( ( 'current_time' ) )
            // InternalMickeyLang.g:17335:3: ( 'current_time' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timeKeyword_3_1_0()); 
            }
            // InternalMickeyLang.g:17336:3: ( 'current_time' )
            // InternalMickeyLang.g:17337:4: 'current_time'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timeKeyword_3_1_0()); 
            }
            match(input,132,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timeKeyword_3_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timeKeyword_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__LiteralAssignment_3_1"


    // $ANTLR start "rule__LiteralValue__LiteralAssignment_4_1"
    // InternalMickeyLang.g:17348:1: rule__LiteralValue__LiteralAssignment_4_1 : ( ( 'current_date' ) ) ;
    public final void rule__LiteralValue__LiteralAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17352:1: ( ( ( 'current_date' ) ) )
            // InternalMickeyLang.g:17353:2: ( ( 'current_date' ) )
            {
            // InternalMickeyLang.g:17353:2: ( ( 'current_date' ) )
            // InternalMickeyLang.g:17354:3: ( 'current_date' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralCurrent_dateKeyword_4_1_0()); 
            }
            // InternalMickeyLang.g:17355:3: ( 'current_date' )
            // InternalMickeyLang.g:17356:4: 'current_date'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralCurrent_dateKeyword_4_1_0()); 
            }
            match(input,133,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralCurrent_dateKeyword_4_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralCurrent_dateKeyword_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__LiteralAssignment_4_1"


    // $ANTLR start "rule__LiteralValue__LiteralAssignment_5_1"
    // InternalMickeyLang.g:17367:1: rule__LiteralValue__LiteralAssignment_5_1 : ( ( 'current_timestamp' ) ) ;
    public final void rule__LiteralValue__LiteralAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17371:1: ( ( ( 'current_timestamp' ) ) )
            // InternalMickeyLang.g:17372:2: ( ( 'current_timestamp' ) )
            {
            // InternalMickeyLang.g:17372:2: ( ( 'current_timestamp' ) )
            // InternalMickeyLang.g:17373:3: ( 'current_timestamp' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timestampKeyword_5_1_0()); 
            }
            // InternalMickeyLang.g:17374:3: ( 'current_timestamp' )
            // InternalMickeyLang.g:17375:4: 'current_timestamp'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timestampKeyword_5_1_0()); 
            }
            match(input,134,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timestampKeyword_5_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLiteralValueAccess().getLiteralCurrent_timestampKeyword_5_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LiteralValue__LiteralAssignment_5_1"


    // $ANTLR start "rule__CreateTableStatement__TemporaryAssignment_2"
    // InternalMickeyLang.g:17386:1: rule__CreateTableStatement__TemporaryAssignment_2 : ( ( 'temp' ) ) ;
    public final void rule__CreateTableStatement__TemporaryAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17390:1: ( ( ( 'temp' ) ) )
            // InternalMickeyLang.g:17391:2: ( ( 'temp' ) )
            {
            // InternalMickeyLang.g:17391:2: ( ( 'temp' ) )
            // InternalMickeyLang.g:17392:3: ( 'temp' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getTemporaryTempKeyword_2_0()); 
            }
            // InternalMickeyLang.g:17393:3: ( 'temp' )
            // InternalMickeyLang.g:17394:4: 'temp'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getTemporaryTempKeyword_2_0()); 
            }
            match(input,135,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getTemporaryTempKeyword_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getTemporaryTempKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__TemporaryAssignment_2"


    // $ANTLR start "rule__CreateTableStatement__NameAssignment_4"
    // InternalMickeyLang.g:17405:1: rule__CreateTableStatement__NameAssignment_4 : ( RULE_ID ) ;
    public final void rule__CreateTableStatement__NameAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17409:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17410:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17410:2: ( RULE_ID )
            // InternalMickeyLang.g:17411:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getNameIDTerminalRuleCall_4_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getNameIDTerminalRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__NameAssignment_4"


    // $ANTLR start "rule__CreateTableStatement__ColumnDefsAssignment_6"
    // InternalMickeyLang.g:17420:1: rule__CreateTableStatement__ColumnDefsAssignment_6 : ( ruleColumnDef ) ;
    public final void rule__CreateTableStatement__ColumnDefsAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17424:1: ( ( ruleColumnDef ) )
            // InternalMickeyLang.g:17425:2: ( ruleColumnDef )
            {
            // InternalMickeyLang.g:17425:2: ( ruleColumnDef )
            // InternalMickeyLang.g:17426:3: ruleColumnDef
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getColumnDefsColumnDefParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleColumnDef();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getColumnDefsColumnDefParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__ColumnDefsAssignment_6"


    // $ANTLR start "rule__CreateTableStatement__ColumnDefsAssignment_7_1"
    // InternalMickeyLang.g:17435:1: rule__CreateTableStatement__ColumnDefsAssignment_7_1 : ( ruleColumnDef ) ;
    public final void rule__CreateTableStatement__ColumnDefsAssignment_7_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17439:1: ( ( ruleColumnDef ) )
            // InternalMickeyLang.g:17440:2: ( ruleColumnDef )
            {
            // InternalMickeyLang.g:17440:2: ( ruleColumnDef )
            // InternalMickeyLang.g:17441:3: ruleColumnDef
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getColumnDefsColumnDefParserRuleCall_7_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleColumnDef();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getColumnDefsColumnDefParserRuleCall_7_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__ColumnDefsAssignment_7_1"


    // $ANTLR start "rule__CreateTableStatement__ConstraintsAssignment_8_1"
    // InternalMickeyLang.g:17450:1: rule__CreateTableStatement__ConstraintsAssignment_8_1 : ( ruleTableConstraint ) ;
    public final void rule__CreateTableStatement__ConstraintsAssignment_8_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17454:1: ( ( ruleTableConstraint ) )
            // InternalMickeyLang.g:17455:2: ( ruleTableConstraint )
            {
            // InternalMickeyLang.g:17455:2: ( ruleTableConstraint )
            // InternalMickeyLang.g:17456:3: ruleTableConstraint
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTableStatementAccess().getConstraintsTableConstraintParserRuleCall_8_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleTableConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTableStatementAccess().getConstraintsTableConstraintParserRuleCall_8_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTableStatement__ConstraintsAssignment_8_1"


    // $ANTLR start "rule__CreateViewStatement__TemporaryAssignment_2"
    // InternalMickeyLang.g:17465:1: rule__CreateViewStatement__TemporaryAssignment_2 : ( ( 'temp' ) ) ;
    public final void rule__CreateViewStatement__TemporaryAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17469:1: ( ( ( 'temp' ) ) )
            // InternalMickeyLang.g:17470:2: ( ( 'temp' ) )
            {
            // InternalMickeyLang.g:17470:2: ( ( 'temp' ) )
            // InternalMickeyLang.g:17471:3: ( 'temp' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getTemporaryTempKeyword_2_0()); 
            }
            // InternalMickeyLang.g:17472:3: ( 'temp' )
            // InternalMickeyLang.g:17473:4: 'temp'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getTemporaryTempKeyword_2_0()); 
            }
            match(input,135,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getTemporaryTempKeyword_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getTemporaryTempKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__TemporaryAssignment_2"


    // $ANTLR start "rule__CreateViewStatement__NameAssignment_4"
    // InternalMickeyLang.g:17484:1: rule__CreateViewStatement__NameAssignment_4 : ( RULE_ID ) ;
    public final void rule__CreateViewStatement__NameAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17488:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17489:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17489:2: ( RULE_ID )
            // InternalMickeyLang.g:17490:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getNameIDTerminalRuleCall_4_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getNameIDTerminalRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__NameAssignment_4"


    // $ANTLR start "rule__CreateViewStatement__SelectStatementAssignment_6"
    // InternalMickeyLang.g:17499:1: rule__CreateViewStatement__SelectStatementAssignment_6 : ( ruleSelectStatement ) ;
    public final void rule__CreateViewStatement__SelectStatementAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17503:1: ( ( ruleSelectStatement ) )
            // InternalMickeyLang.g:17504:2: ( ruleSelectStatement )
            {
            // InternalMickeyLang.g:17504:2: ( ruleSelectStatement )
            // InternalMickeyLang.g:17505:3: ruleSelectStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateViewStatementAccess().getSelectStatementSelectStatementParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateViewStatementAccess().getSelectStatementSelectStatementParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateViewStatement__SelectStatementAssignment_6"


    // $ANTLR start "rule__CreateTriggerStatement__TemporaryAssignment_1"
    // InternalMickeyLang.g:17514:1: rule__CreateTriggerStatement__TemporaryAssignment_1 : ( ( 'temp' ) ) ;
    public final void rule__CreateTriggerStatement__TemporaryAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17518:1: ( ( ( 'temp' ) ) )
            // InternalMickeyLang.g:17519:2: ( ( 'temp' ) )
            {
            // InternalMickeyLang.g:17519:2: ( ( 'temp' ) )
            // InternalMickeyLang.g:17520:3: ( 'temp' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTemporaryTempKeyword_1_0()); 
            }
            // InternalMickeyLang.g:17521:3: ( 'temp' )
            // InternalMickeyLang.g:17522:4: 'temp'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTemporaryTempKeyword_1_0()); 
            }
            match(input,135,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTemporaryTempKeyword_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTemporaryTempKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__TemporaryAssignment_1"


    // $ANTLR start "rule__CreateTriggerStatement__NameAssignment_3"
    // InternalMickeyLang.g:17533:1: rule__CreateTriggerStatement__NameAssignment_3 : ( RULE_ID ) ;
    public final void rule__CreateTriggerStatement__NameAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17537:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17538:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17538:2: ( RULE_ID )
            // InternalMickeyLang.g:17539:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getNameIDTerminalRuleCall_3_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getNameIDTerminalRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__NameAssignment_3"


    // $ANTLR start "rule__CreateTriggerStatement__WhenAssignment_4"
    // InternalMickeyLang.g:17548:1: rule__CreateTriggerStatement__WhenAssignment_4 : ( ( rule__CreateTriggerStatement__WhenAlternatives_4_0 ) ) ;
    public final void rule__CreateTriggerStatement__WhenAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17552:1: ( ( ( rule__CreateTriggerStatement__WhenAlternatives_4_0 ) ) )
            // InternalMickeyLang.g:17553:2: ( ( rule__CreateTriggerStatement__WhenAlternatives_4_0 ) )
            {
            // InternalMickeyLang.g:17553:2: ( ( rule__CreateTriggerStatement__WhenAlternatives_4_0 ) )
            // InternalMickeyLang.g:17554:3: ( rule__CreateTriggerStatement__WhenAlternatives_4_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getWhenAlternatives_4_0()); 
            }
            // InternalMickeyLang.g:17555:3: ( rule__CreateTriggerStatement__WhenAlternatives_4_0 )
            // InternalMickeyLang.g:17555:4: rule__CreateTriggerStatement__WhenAlternatives_4_0
            {
            pushFollow(FOLLOW_2);
            rule__CreateTriggerStatement__WhenAlternatives_4_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getWhenAlternatives_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__WhenAssignment_4"


    // $ANTLR start "rule__CreateTriggerStatement__EventTypeAssignment_5_0"
    // InternalMickeyLang.g:17563:1: rule__CreateTriggerStatement__EventTypeAssignment_5_0 : ( ( 'delete' ) ) ;
    public final void rule__CreateTriggerStatement__EventTypeAssignment_5_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17567:1: ( ( ( 'delete' ) ) )
            // InternalMickeyLang.g:17568:2: ( ( 'delete' ) )
            {
            // InternalMickeyLang.g:17568:2: ( ( 'delete' ) )
            // InternalMickeyLang.g:17569:3: ( 'delete' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeDeleteKeyword_5_0_0()); 
            }
            // InternalMickeyLang.g:17570:3: ( 'delete' )
            // InternalMickeyLang.g:17571:4: 'delete'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeDeleteKeyword_5_0_0()); 
            }
            match(input,111,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeDeleteKeyword_5_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeDeleteKeyword_5_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__EventTypeAssignment_5_0"


    // $ANTLR start "rule__CreateTriggerStatement__EventTypeAssignment_5_1"
    // InternalMickeyLang.g:17582:1: rule__CreateTriggerStatement__EventTypeAssignment_5_1 : ( ( 'insert' ) ) ;
    public final void rule__CreateTriggerStatement__EventTypeAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17586:1: ( ( ( 'insert' ) ) )
            // InternalMickeyLang.g:17587:2: ( ( 'insert' ) )
            {
            // InternalMickeyLang.g:17587:2: ( ( 'insert' ) )
            // InternalMickeyLang.g:17588:3: ( 'insert' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeInsertKeyword_5_1_0()); 
            }
            // InternalMickeyLang.g:17589:3: ( 'insert' )
            // InternalMickeyLang.g:17590:4: 'insert'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeInsertKeyword_5_1_0()); 
            }
            match(input,113,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeInsertKeyword_5_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeInsertKeyword_5_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__EventTypeAssignment_5_1"


    // $ANTLR start "rule__CreateTriggerStatement__EventTypeAssignment_5_2_0"
    // InternalMickeyLang.g:17601:1: rule__CreateTriggerStatement__EventTypeAssignment_5_2_0 : ( ( 'update' ) ) ;
    public final void rule__CreateTriggerStatement__EventTypeAssignment_5_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17605:1: ( ( ( 'update' ) ) )
            // InternalMickeyLang.g:17606:2: ( ( 'update' ) )
            {
            // InternalMickeyLang.g:17606:2: ( ( 'update' ) )
            // InternalMickeyLang.g:17607:3: ( 'update' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeUpdateKeyword_5_2_0_0()); 
            }
            // InternalMickeyLang.g:17608:3: ( 'update' )
            // InternalMickeyLang.g:17609:4: 'update'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getEventTypeUpdateKeyword_5_2_0_0()); 
            }
            match(input,116,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeUpdateKeyword_5_2_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getEventTypeUpdateKeyword_5_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__EventTypeAssignment_5_2_0"


    // $ANTLR start "rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1"
    // InternalMickeyLang.g:17620:1: rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1 : ( RULE_ID ) ;
    public final void rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17624:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17625:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17625:2: ( RULE_ID )
            // InternalMickeyLang.g:17626:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesIDTerminalRuleCall_5_2_1_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesIDTerminalRuleCall_5_2_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_1"


    // $ANTLR start "rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1"
    // InternalMickeyLang.g:17635:1: rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1 : ( RULE_ID ) ;
    public final void rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17639:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17640:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17640:2: ( RULE_ID )
            // InternalMickeyLang.g:17641:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesIDTerminalRuleCall_5_2_1_2_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getUpdateColumnNamesIDTerminalRuleCall_5_2_1_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__UpdateColumnNamesAssignment_5_2_1_2_1"


    // $ANTLR start "rule__CreateTriggerStatement__TableAssignment_7"
    // InternalMickeyLang.g:17650:1: rule__CreateTriggerStatement__TableAssignment_7 : ( ( RULE_ID ) ) ;
    public final void rule__CreateTriggerStatement__TableAssignment_7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17654:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17655:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17655:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17656:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTableTableDefinitionCrossReference_7_0()); 
            }
            // InternalMickeyLang.g:17657:3: ( RULE_ID )
            // InternalMickeyLang.g:17658:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getTableTableDefinitionIDTerminalRuleCall_7_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTableTableDefinitionIDTerminalRuleCall_7_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getTableTableDefinitionCrossReference_7_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__TableAssignment_7"


    // $ANTLR start "rule__CreateTriggerStatement__ForEachRowAssignment_8"
    // InternalMickeyLang.g:17669:1: rule__CreateTriggerStatement__ForEachRowAssignment_8 : ( ( 'for each row' ) ) ;
    public final void rule__CreateTriggerStatement__ForEachRowAssignment_8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17673:1: ( ( ( 'for each row' ) ) )
            // InternalMickeyLang.g:17674:2: ( ( 'for each row' ) )
            {
            // InternalMickeyLang.g:17674:2: ( ( 'for each row' ) )
            // InternalMickeyLang.g:17675:3: ( 'for each row' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getForEachRowForEachRowKeyword_8_0()); 
            }
            // InternalMickeyLang.g:17676:3: ( 'for each row' )
            // InternalMickeyLang.g:17677:4: 'for each row'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getForEachRowForEachRowKeyword_8_0()); 
            }
            match(input,136,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getForEachRowForEachRowKeyword_8_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getForEachRowForEachRowKeyword_8_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__ForEachRowAssignment_8"


    // $ANTLR start "rule__CreateTriggerStatement__WhenExpressionAssignment_9_1"
    // InternalMickeyLang.g:17688:1: rule__CreateTriggerStatement__WhenExpressionAssignment_9_1 : ( ruleSqlExpression ) ;
    public final void rule__CreateTriggerStatement__WhenExpressionAssignment_9_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17692:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:17693:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:17693:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:17694:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getWhenExpressionSqlExpressionParserRuleCall_9_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getWhenExpressionSqlExpressionParserRuleCall_9_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__WhenExpressionAssignment_9_1"


    // $ANTLR start "rule__CreateTriggerStatement__StatementsAssignment_11_0"
    // InternalMickeyLang.g:17703:1: rule__CreateTriggerStatement__StatementsAssignment_11_0 : ( ruleDMLStatement ) ;
    public final void rule__CreateTriggerStatement__StatementsAssignment_11_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17707:1: ( ( ruleDMLStatement ) )
            // InternalMickeyLang.g:17708:2: ( ruleDMLStatement )
            {
            // InternalMickeyLang.g:17708:2: ( ruleDMLStatement )
            // InternalMickeyLang.g:17709:3: ruleDMLStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getStatementsDMLStatementParserRuleCall_11_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleDMLStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getStatementsDMLStatementParserRuleCall_11_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__StatementsAssignment_11_0"


    // $ANTLR start "rule__CreateTriggerStatement__StatementsAssignment_11_2_0"
    // InternalMickeyLang.g:17718:1: rule__CreateTriggerStatement__StatementsAssignment_11_2_0 : ( ruleDMLStatement ) ;
    public final void rule__CreateTriggerStatement__StatementsAssignment_11_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17722:1: ( ( ruleDMLStatement ) )
            // InternalMickeyLang.g:17723:2: ( ruleDMLStatement )
            {
            // InternalMickeyLang.g:17723:2: ( ruleDMLStatement )
            // InternalMickeyLang.g:17724:3: ruleDMLStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateTriggerStatementAccess().getStatementsDMLStatementParserRuleCall_11_2_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleDMLStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateTriggerStatementAccess().getStatementsDMLStatementParserRuleCall_11_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateTriggerStatement__StatementsAssignment_11_2_0"


    // $ANTLR start "rule__AlterTableRenameStatement__TableAssignment_3"
    // InternalMickeyLang.g:17733:1: rule__AlterTableRenameStatement__TableAssignment_3 : ( ( RULE_ID ) ) ;
    public final void rule__AlterTableRenameStatement__TableAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17737:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17738:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17738:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17739:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getTableTableDefinitionCrossReference_3_0()); 
            }
            // InternalMickeyLang.g:17740:3: ( RULE_ID )
            // InternalMickeyLang.g:17741:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getTableTableDefinitionIDTerminalRuleCall_3_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getTableTableDefinitionIDTerminalRuleCall_3_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getTableTableDefinitionCrossReference_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__TableAssignment_3"


    // $ANTLR start "rule__AlterTableRenameStatement__NameAssignment_5"
    // InternalMickeyLang.g:17752:1: rule__AlterTableRenameStatement__NameAssignment_5 : ( RULE_ID ) ;
    public final void rule__AlterTableRenameStatement__NameAssignment_5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17756:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17757:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17757:2: ( RULE_ID )
            // InternalMickeyLang.g:17758:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableRenameStatementAccess().getNameIDTerminalRuleCall_5_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableRenameStatementAccess().getNameIDTerminalRuleCall_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableRenameStatement__NameAssignment_5"


    // $ANTLR start "rule__AlterTableAddColumnStatement__TableAssignment_2"
    // InternalMickeyLang.g:17767:1: rule__AlterTableAddColumnStatement__TableAssignment_2 : ( ( RULE_ID ) ) ;
    public final void rule__AlterTableAddColumnStatement__TableAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17771:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17772:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17772:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17773:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }
            // InternalMickeyLang.g:17774:3: ( RULE_ID )
            // InternalMickeyLang.g:17775:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__TableAssignment_2"


    // $ANTLR start "rule__AlterTableAddColumnStatement__ColumnDefAssignment_4"
    // InternalMickeyLang.g:17786:1: rule__AlterTableAddColumnStatement__ColumnDefAssignment_4 : ( ruleColumnDef ) ;
    public final void rule__AlterTableAddColumnStatement__ColumnDefAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17790:1: ( ( ruleColumnDef ) )
            // InternalMickeyLang.g:17791:2: ( ruleColumnDef )
            {
            // InternalMickeyLang.g:17791:2: ( ruleColumnDef )
            // InternalMickeyLang.g:17792:3: ruleColumnDef
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAlterTableAddColumnStatementAccess().getColumnDefColumnDefParserRuleCall_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleColumnDef();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAlterTableAddColumnStatementAccess().getColumnDefColumnDefParserRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AlterTableAddColumnStatement__ColumnDefAssignment_4"


    // $ANTLR start "rule__DropTableStatement__IfExistsAssignment_2"
    // InternalMickeyLang.g:17801:1: rule__DropTableStatement__IfExistsAssignment_2 : ( ( 'if exists' ) ) ;
    public final void rule__DropTableStatement__IfExistsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17805:1: ( ( ( 'if exists' ) ) )
            // InternalMickeyLang.g:17806:2: ( ( 'if exists' ) )
            {
            // InternalMickeyLang.g:17806:2: ( ( 'if exists' ) )
            // InternalMickeyLang.g:17807:3: ( 'if exists' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            // InternalMickeyLang.g:17808:3: ( 'if exists' )
            // InternalMickeyLang.g:17809:4: 'if exists'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            match(input,137,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__IfExistsAssignment_2"


    // $ANTLR start "rule__DropTableStatement__TableAssignment_3"
    // InternalMickeyLang.g:17820:1: rule__DropTableStatement__TableAssignment_3 : ( ( RULE_ID ) ) ;
    public final void rule__DropTableStatement__TableAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17824:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17825:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17825:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17826:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getTableTableDefinitionCrossReference_3_0()); 
            }
            // InternalMickeyLang.g:17827:3: ( RULE_ID )
            // InternalMickeyLang.g:17828:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTableStatementAccess().getTableTableDefinitionIDTerminalRuleCall_3_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getTableTableDefinitionIDTerminalRuleCall_3_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTableStatementAccess().getTableTableDefinitionCrossReference_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTableStatement__TableAssignment_3"


    // $ANTLR start "rule__DropTriggerStatement__IfExistsAssignment_2"
    // InternalMickeyLang.g:17839:1: rule__DropTriggerStatement__IfExistsAssignment_2 : ( ( 'if exists' ) ) ;
    public final void rule__DropTriggerStatement__IfExistsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17843:1: ( ( ( 'if exists' ) ) )
            // InternalMickeyLang.g:17844:2: ( ( 'if exists' ) )
            {
            // InternalMickeyLang.g:17844:2: ( ( 'if exists' ) )
            // InternalMickeyLang.g:17845:3: ( 'if exists' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            // InternalMickeyLang.g:17846:3: ( 'if exists' )
            // InternalMickeyLang.g:17847:4: 'if exists'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            match(input,137,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__IfExistsAssignment_2"


    // $ANTLR start "rule__DropTriggerStatement__TriggerAssignment_3"
    // InternalMickeyLang.g:17858:1: rule__DropTriggerStatement__TriggerAssignment_3 : ( ( RULE_ID ) ) ;
    public final void rule__DropTriggerStatement__TriggerAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17862:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17863:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17863:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17864:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getTriggerCreateTriggerStatementCrossReference_3_0()); 
            }
            // InternalMickeyLang.g:17865:3: ( RULE_ID )
            // InternalMickeyLang.g:17866:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropTriggerStatementAccess().getTriggerCreateTriggerStatementIDTerminalRuleCall_3_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getTriggerCreateTriggerStatementIDTerminalRuleCall_3_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropTriggerStatementAccess().getTriggerCreateTriggerStatementCrossReference_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropTriggerStatement__TriggerAssignment_3"


    // $ANTLR start "rule__DropViewStatement__IfExistsAssignment_2"
    // InternalMickeyLang.g:17877:1: rule__DropViewStatement__IfExistsAssignment_2 : ( ( 'if exists' ) ) ;
    public final void rule__DropViewStatement__IfExistsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17881:1: ( ( ( 'if exists' ) ) )
            // InternalMickeyLang.g:17882:2: ( ( 'if exists' ) )
            {
            // InternalMickeyLang.g:17882:2: ( ( 'if exists' ) )
            // InternalMickeyLang.g:17883:3: ( 'if exists' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            // InternalMickeyLang.g:17884:3: ( 'if exists' )
            // InternalMickeyLang.g:17885:4: 'if exists'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            match(input,137,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__IfExistsAssignment_2"


    // $ANTLR start "rule__DropViewStatement__ViewAssignment_3"
    // InternalMickeyLang.g:17896:1: rule__DropViewStatement__ViewAssignment_3 : ( ( RULE_ID ) ) ;
    public final void rule__DropViewStatement__ViewAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17900:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17901:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17901:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17902:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getViewCreateViewStatementCrossReference_3_0()); 
            }
            // InternalMickeyLang.g:17903:3: ( RULE_ID )
            // InternalMickeyLang.g:17904:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropViewStatementAccess().getViewCreateViewStatementIDTerminalRuleCall_3_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getViewCreateViewStatementIDTerminalRuleCall_3_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropViewStatementAccess().getViewCreateViewStatementCrossReference_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropViewStatement__ViewAssignment_3"


    // $ANTLR start "rule__CreateIndexStatement__UniqueAssignment_1"
    // InternalMickeyLang.g:17915:1: rule__CreateIndexStatement__UniqueAssignment_1 : ( ( 'unique' ) ) ;
    public final void rule__CreateIndexStatement__UniqueAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17919:1: ( ( ( 'unique' ) ) )
            // InternalMickeyLang.g:17920:2: ( ( 'unique' ) )
            {
            // InternalMickeyLang.g:17920:2: ( ( 'unique' ) )
            // InternalMickeyLang.g:17921:3: ( 'unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getUniqueUniqueKeyword_1_0()); 
            }
            // InternalMickeyLang.g:17922:3: ( 'unique' )
            // InternalMickeyLang.g:17923:4: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getUniqueUniqueKeyword_1_0()); 
            }
            match(input,105,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getUniqueUniqueKeyword_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getUniqueUniqueKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__UniqueAssignment_1"


    // $ANTLR start "rule__CreateIndexStatement__NameAssignment_3"
    // InternalMickeyLang.g:17934:1: rule__CreateIndexStatement__NameAssignment_3 : ( RULE_ID ) ;
    public final void rule__CreateIndexStatement__NameAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17938:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17939:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:17939:2: ( RULE_ID )
            // InternalMickeyLang.g:17940:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getNameIDTerminalRuleCall_3_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getNameIDTerminalRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__NameAssignment_3"


    // $ANTLR start "rule__CreateIndexStatement__TableAssignment_5"
    // InternalMickeyLang.g:17949:1: rule__CreateIndexStatement__TableAssignment_5 : ( ( RULE_ID ) ) ;
    public final void rule__CreateIndexStatement__TableAssignment_5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17953:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:17954:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:17954:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:17955:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getTableTableDefinitionCrossReference_5_0()); 
            }
            // InternalMickeyLang.g:17956:3: ( RULE_ID )
            // InternalMickeyLang.g:17957:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getTableTableDefinitionIDTerminalRuleCall_5_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getTableTableDefinitionIDTerminalRuleCall_5_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getTableTableDefinitionCrossReference_5_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__TableAssignment_5"


    // $ANTLR start "rule__CreateIndexStatement__ColumnsAssignment_7"
    // InternalMickeyLang.g:17968:1: rule__CreateIndexStatement__ColumnsAssignment_7 : ( ruleIndexedColumn ) ;
    public final void rule__CreateIndexStatement__ColumnsAssignment_7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17972:1: ( ( ruleIndexedColumn ) )
            // InternalMickeyLang.g:17973:2: ( ruleIndexedColumn )
            {
            // InternalMickeyLang.g:17973:2: ( ruleIndexedColumn )
            // InternalMickeyLang.g:17974:3: ruleIndexedColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getColumnsIndexedColumnParserRuleCall_7_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getColumnsIndexedColumnParserRuleCall_7_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__ColumnsAssignment_7"


    // $ANTLR start "rule__CreateIndexStatement__ColumnsAssignment_8_1"
    // InternalMickeyLang.g:17983:1: rule__CreateIndexStatement__ColumnsAssignment_8_1 : ( ruleIndexedColumn ) ;
    public final void rule__CreateIndexStatement__ColumnsAssignment_8_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:17987:1: ( ( ruleIndexedColumn ) )
            // InternalMickeyLang.g:17988:2: ( ruleIndexedColumn )
            {
            // InternalMickeyLang.g:17988:2: ( ruleIndexedColumn )
            // InternalMickeyLang.g:17989:3: ruleIndexedColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCreateIndexStatementAccess().getColumnsIndexedColumnParserRuleCall_8_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCreateIndexStatementAccess().getColumnsIndexedColumnParserRuleCall_8_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CreateIndexStatement__ColumnsAssignment_8_1"


    // $ANTLR start "rule__DropIndexStatement__IfExistsAssignment_2"
    // InternalMickeyLang.g:17998:1: rule__DropIndexStatement__IfExistsAssignment_2 : ( ( 'if exists' ) ) ;
    public final void rule__DropIndexStatement__IfExistsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18002:1: ( ( ( 'if exists' ) ) )
            // InternalMickeyLang.g:18003:2: ( ( 'if exists' ) )
            {
            // InternalMickeyLang.g:18003:2: ( ( 'if exists' ) )
            // InternalMickeyLang.g:18004:3: ( 'if exists' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            // InternalMickeyLang.g:18005:3: ( 'if exists' )
            // InternalMickeyLang.g:18006:4: 'if exists'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }
            match(input,137,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIfExistsIfExistsKeyword_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__IfExistsAssignment_2"


    // $ANTLR start "rule__DropIndexStatement__IndexAssignment_3"
    // InternalMickeyLang.g:18017:1: rule__DropIndexStatement__IndexAssignment_3 : ( ( RULE_ID ) ) ;
    public final void rule__DropIndexStatement__IndexAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18021:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18022:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18022:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18023:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIndexCreateIndexStatementCrossReference_3_0()); 
            }
            // InternalMickeyLang.g:18024:3: ( RULE_ID )
            // InternalMickeyLang.g:18025:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDropIndexStatementAccess().getIndexCreateIndexStatementIDTerminalRuleCall_3_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIndexCreateIndexStatementIDTerminalRuleCall_3_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDropIndexStatementAccess().getIndexCreateIndexStatementCrossReference_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DropIndexStatement__IndexAssignment_3"


    // $ANTLR start "rule__ColumnDef__NameAssignment_1"
    // InternalMickeyLang.g:18036:1: rule__ColumnDef__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__ColumnDef__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18040:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18041:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:18041:2: ( RULE_ID )
            // InternalMickeyLang.g:18042:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__NameAssignment_1"


    // $ANTLR start "rule__ColumnDef__TypeAssignment_2"
    // InternalMickeyLang.g:18051:1: rule__ColumnDef__TypeAssignment_2 : ( ruleColumnType ) ;
    public final void rule__ColumnDef__TypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18055:1: ( ( ruleColumnType ) )
            // InternalMickeyLang.g:18056:2: ( ruleColumnType )
            {
            // InternalMickeyLang.g:18056:2: ( ruleColumnType )
            // InternalMickeyLang.g:18057:3: ruleColumnType
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getTypeColumnTypeEnumRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleColumnType();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getTypeColumnTypeEnumRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__TypeAssignment_2"


    // $ANTLR start "rule__ColumnDef__ConstraintsAssignment_3"
    // InternalMickeyLang.g:18066:1: rule__ColumnDef__ConstraintsAssignment_3 : ( ruleColumnConstraint ) ;
    public final void rule__ColumnDef__ConstraintsAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18070:1: ( ( ruleColumnConstraint ) )
            // InternalMickeyLang.g:18071:2: ( ruleColumnConstraint )
            {
            // InternalMickeyLang.g:18071:2: ( ruleColumnConstraint )
            // InternalMickeyLang.g:18072:3: ruleColumnConstraint
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnDefAccess().getConstraintsColumnConstraintParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleColumnConstraint();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnDefAccess().getConstraintsColumnConstraintParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnDef__ConstraintsAssignment_3"


    // $ANTLR start "rule__ColumnConstraint__AscAssignment_0_2_0"
    // InternalMickeyLang.g:18081:1: rule__ColumnConstraint__AscAssignment_0_2_0 : ( ( 'asc' ) ) ;
    public final void rule__ColumnConstraint__AscAssignment_0_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18085:1: ( ( ( 'asc' ) ) )
            // InternalMickeyLang.g:18086:2: ( ( 'asc' ) )
            {
            // InternalMickeyLang.g:18086:2: ( ( 'asc' ) )
            // InternalMickeyLang.g:18087:3: ( 'asc' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAscAscKeyword_0_2_0_0()); 
            }
            // InternalMickeyLang.g:18088:3: ( 'asc' )
            // InternalMickeyLang.g:18089:4: 'asc'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAscAscKeyword_0_2_0_0()); 
            }
            match(input,124,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAscAscKeyword_0_2_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAscAscKeyword_0_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__AscAssignment_0_2_0"


    // $ANTLR start "rule__ColumnConstraint__DescAssignment_0_2_1"
    // InternalMickeyLang.g:18100:1: rule__ColumnConstraint__DescAssignment_0_2_1 : ( ( 'desc' ) ) ;
    public final void rule__ColumnConstraint__DescAssignment_0_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18104:1: ( ( ( 'desc' ) ) )
            // InternalMickeyLang.g:18105:2: ( ( 'desc' ) )
            {
            // InternalMickeyLang.g:18105:2: ( ( 'desc' ) )
            // InternalMickeyLang.g:18106:3: ( 'desc' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getDescDescKeyword_0_2_1_0()); 
            }
            // InternalMickeyLang.g:18107:3: ( 'desc' )
            // InternalMickeyLang.g:18108:4: 'desc'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getDescDescKeyword_0_2_1_0()); 
            }
            match(input,125,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getDescDescKeyword_0_2_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getDescDescKeyword_0_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__DescAssignment_0_2_1"


    // $ANTLR start "rule__ColumnConstraint__AutoincrementAssignment_0_3"
    // InternalMickeyLang.g:18119:1: rule__ColumnConstraint__AutoincrementAssignment_0_3 : ( ( 'autoincrement' ) ) ;
    public final void rule__ColumnConstraint__AutoincrementAssignment_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18123:1: ( ( ( 'autoincrement' ) ) )
            // InternalMickeyLang.g:18124:2: ( ( 'autoincrement' ) )
            {
            // InternalMickeyLang.g:18124:2: ( ( 'autoincrement' ) )
            // InternalMickeyLang.g:18125:3: ( 'autoincrement' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAutoincrementAutoincrementKeyword_0_3_0()); 
            }
            // InternalMickeyLang.g:18126:3: ( 'autoincrement' )
            // InternalMickeyLang.g:18127:4: 'autoincrement'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getAutoincrementAutoincrementKeyword_0_3_0()); 
            }
            match(input,138,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAutoincrementAutoincrementKeyword_0_3_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getAutoincrementAutoincrementKeyword_0_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__AutoincrementAssignment_0_3"


    // $ANTLR start "rule__ColumnConstraint__ConflictClauseAssignment_1_2"
    // InternalMickeyLang.g:18138:1: rule__ColumnConstraint__ConflictClauseAssignment_1_2 : ( ruleConflictClause ) ;
    public final void rule__ColumnConstraint__ConflictClauseAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18142:1: ( ( ruleConflictClause ) )
            // InternalMickeyLang.g:18143:2: ( ruleConflictClause )
            {
            // InternalMickeyLang.g:18143:2: ( ruleConflictClause )
            // InternalMickeyLang.g:18144:3: ruleConflictClause
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getConflictClauseConflictClauseParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictClause();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getConflictClauseConflictClauseParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__ConflictClauseAssignment_1_2"


    // $ANTLR start "rule__ColumnConstraint__ConflictClauseAssignment_2_2"
    // InternalMickeyLang.g:18153:1: rule__ColumnConstraint__ConflictClauseAssignment_2_2 : ( ruleConflictClause ) ;
    public final void rule__ColumnConstraint__ConflictClauseAssignment_2_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18157:1: ( ( ruleConflictClause ) )
            // InternalMickeyLang.g:18158:2: ( ruleConflictClause )
            {
            // InternalMickeyLang.g:18158:2: ( ruleConflictClause )
            // InternalMickeyLang.g:18159:3: ruleConflictClause
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getConflictClauseConflictClauseParserRuleCall_2_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictClause();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getConflictClauseConflictClauseParserRuleCall_2_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__ConflictClauseAssignment_2_2"


    // $ANTLR start "rule__ColumnConstraint__DefaultValueAssignment_3_2"
    // InternalMickeyLang.g:18168:1: rule__ColumnConstraint__DefaultValueAssignment_3_2 : ( ruleDefaultValue ) ;
    public final void rule__ColumnConstraint__DefaultValueAssignment_3_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18172:1: ( ( ruleDefaultValue ) )
            // InternalMickeyLang.g:18173:2: ( ruleDefaultValue )
            {
            // InternalMickeyLang.g:18173:2: ( ruleDefaultValue )
            // InternalMickeyLang.g:18174:3: ruleDefaultValue
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getDefaultValueDefaultValueParserRuleCall_3_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleDefaultValue();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getDefaultValueDefaultValueParserRuleCall_3_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__DefaultValueAssignment_3_2"


    // $ANTLR start "rule__ColumnConstraint__ExpressionAssignment_4_3"
    // InternalMickeyLang.g:18183:1: rule__ColumnConstraint__ExpressionAssignment_4_3 : ( ruleSqlExpression ) ;
    public final void rule__ColumnConstraint__ExpressionAssignment_4_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18187:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18188:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18188:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18189:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getColumnConstraintAccess().getExpressionSqlExpressionParserRuleCall_4_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getColumnConstraintAccess().getExpressionSqlExpressionParserRuleCall_4_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ColumnConstraint__ExpressionAssignment_4_3"


    // $ANTLR start "rule__UniqueTableConstraint__NameAssignment_0_1"
    // InternalMickeyLang.g:18198:1: rule__UniqueTableConstraint__NameAssignment_0_1 : ( RULE_ID ) ;
    public final void rule__UniqueTableConstraint__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18202:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18203:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:18203:2: ( RULE_ID )
            // InternalMickeyLang.g:18204:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getNameIDTerminalRuleCall_0_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getNameIDTerminalRuleCall_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__NameAssignment_0_1"


    // $ANTLR start "rule__UniqueTableConstraint__ColumnsAssignment_3"
    // InternalMickeyLang.g:18213:1: rule__UniqueTableConstraint__ColumnsAssignment_3 : ( ruleIndexedColumn ) ;
    public final void rule__UniqueTableConstraint__ColumnsAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18217:1: ( ( ruleIndexedColumn ) )
            // InternalMickeyLang.g:18218:2: ( ruleIndexedColumn )
            {
            // InternalMickeyLang.g:18218:2: ( ruleIndexedColumn )
            // InternalMickeyLang.g:18219:3: ruleIndexedColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getColumnsIndexedColumnParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getColumnsIndexedColumnParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__ColumnsAssignment_3"


    // $ANTLR start "rule__UniqueTableConstraint__ColumnsAssignment_4_1"
    // InternalMickeyLang.g:18228:1: rule__UniqueTableConstraint__ColumnsAssignment_4_1 : ( ruleIndexedColumn ) ;
    public final void rule__UniqueTableConstraint__ColumnsAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18232:1: ( ( ruleIndexedColumn ) )
            // InternalMickeyLang.g:18233:2: ( ruleIndexedColumn )
            {
            // InternalMickeyLang.g:18233:2: ( ruleIndexedColumn )
            // InternalMickeyLang.g:18234:3: ruleIndexedColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getColumnsIndexedColumnParserRuleCall_4_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getColumnsIndexedColumnParserRuleCall_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__ColumnsAssignment_4_1"


    // $ANTLR start "rule__UniqueTableConstraint__ConflictClauseAssignment_6"
    // InternalMickeyLang.g:18243:1: rule__UniqueTableConstraint__ConflictClauseAssignment_6 : ( ruleConflictClause ) ;
    public final void rule__UniqueTableConstraint__ConflictClauseAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18247:1: ( ( ruleConflictClause ) )
            // InternalMickeyLang.g:18248:2: ( ruleConflictClause )
            {
            // InternalMickeyLang.g:18248:2: ( ruleConflictClause )
            // InternalMickeyLang.g:18249:3: ruleConflictClause
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUniqueTableConstraintAccess().getConflictClauseConflictClauseParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictClause();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUniqueTableConstraintAccess().getConflictClauseConflictClauseParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UniqueTableConstraint__ConflictClauseAssignment_6"


    // $ANTLR start "rule__PrimaryConstraint__NameAssignment_0_1"
    // InternalMickeyLang.g:18258:1: rule__PrimaryConstraint__NameAssignment_0_1 : ( RULE_ID ) ;
    public final void rule__PrimaryConstraint__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18262:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18263:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:18263:2: ( RULE_ID )
            // InternalMickeyLang.g:18264:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getNameIDTerminalRuleCall_0_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getNameIDTerminalRuleCall_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__NameAssignment_0_1"


    // $ANTLR start "rule__PrimaryConstraint__ColumnsAssignment_3"
    // InternalMickeyLang.g:18273:1: rule__PrimaryConstraint__ColumnsAssignment_3 : ( ruleIndexedColumn ) ;
    public final void rule__PrimaryConstraint__ColumnsAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18277:1: ( ( ruleIndexedColumn ) )
            // InternalMickeyLang.g:18278:2: ( ruleIndexedColumn )
            {
            // InternalMickeyLang.g:18278:2: ( ruleIndexedColumn )
            // InternalMickeyLang.g:18279:3: ruleIndexedColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getColumnsIndexedColumnParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getColumnsIndexedColumnParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__ColumnsAssignment_3"


    // $ANTLR start "rule__PrimaryConstraint__ColumnsAssignment_4_1"
    // InternalMickeyLang.g:18288:1: rule__PrimaryConstraint__ColumnsAssignment_4_1 : ( ruleIndexedColumn ) ;
    public final void rule__PrimaryConstraint__ColumnsAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18292:1: ( ( ruleIndexedColumn ) )
            // InternalMickeyLang.g:18293:2: ( ruleIndexedColumn )
            {
            // InternalMickeyLang.g:18293:2: ( ruleIndexedColumn )
            // InternalMickeyLang.g:18294:3: ruleIndexedColumn
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getColumnsIndexedColumnParserRuleCall_4_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIndexedColumn();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getColumnsIndexedColumnParserRuleCall_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__ColumnsAssignment_4_1"


    // $ANTLR start "rule__PrimaryConstraint__ConflictClauseAssignment_6"
    // InternalMickeyLang.g:18303:1: rule__PrimaryConstraint__ConflictClauseAssignment_6 : ( ruleConflictClause ) ;
    public final void rule__PrimaryConstraint__ConflictClauseAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18307:1: ( ( ruleConflictClause ) )
            // InternalMickeyLang.g:18308:2: ( ruleConflictClause )
            {
            // InternalMickeyLang.g:18308:2: ( ruleConflictClause )
            // InternalMickeyLang.g:18309:3: ruleConflictClause
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryConstraintAccess().getConflictClauseConflictClauseParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictClause();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryConstraintAccess().getConflictClauseConflictClauseParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryConstraint__ConflictClauseAssignment_6"


    // $ANTLR start "rule__CheckTableConstraint__NameAssignment_0_1"
    // InternalMickeyLang.g:18318:1: rule__CheckTableConstraint__NameAssignment_0_1 : ( RULE_ID ) ;
    public final void rule__CheckTableConstraint__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18322:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18323:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:18323:2: ( RULE_ID )
            // InternalMickeyLang.g:18324:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getNameIDTerminalRuleCall_0_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getNameIDTerminalRuleCall_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__NameAssignment_0_1"


    // $ANTLR start "rule__CheckTableConstraint__ExpressionAssignment_3"
    // InternalMickeyLang.g:18333:1: rule__CheckTableConstraint__ExpressionAssignment_3 : ( ruleSqlExpression ) ;
    public final void rule__CheckTableConstraint__ExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18337:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18338:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18338:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18339:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCheckTableConstraintAccess().getExpressionSqlExpressionParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCheckTableConstraintAccess().getExpressionSqlExpressionParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CheckTableConstraint__ExpressionAssignment_3"


    // $ANTLR start "rule__IndexedColumn__ColumnReferenceAssignment_0"
    // InternalMickeyLang.g:18348:1: rule__IndexedColumn__ColumnReferenceAssignment_0 : ( ( RULE_ID ) ) ;
    public final void rule__IndexedColumn__ColumnReferenceAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18352:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18353:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18353:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18354:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getColumnReferenceColumnDefCrossReference_0_0()); 
            }
            // InternalMickeyLang.g:18355:3: ( RULE_ID )
            // InternalMickeyLang.g:18356:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getColumnReferenceColumnDefIDTerminalRuleCall_0_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getColumnReferenceColumnDefIDTerminalRuleCall_0_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getColumnReferenceColumnDefCrossReference_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__ColumnReferenceAssignment_0"


    // $ANTLR start "rule__IndexedColumn__CollationNameAssignment_1_1"
    // InternalMickeyLang.g:18367:1: rule__IndexedColumn__CollationNameAssignment_1_1 : ( RULE_ID ) ;
    public final void rule__IndexedColumn__CollationNameAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18371:1: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18372:2: ( RULE_ID )
            {
            // InternalMickeyLang.g:18372:2: ( RULE_ID )
            // InternalMickeyLang.g:18373:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getCollationNameIDTerminalRuleCall_1_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getCollationNameIDTerminalRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__CollationNameAssignment_1_1"


    // $ANTLR start "rule__IndexedColumn__AscAssignment_2_0"
    // InternalMickeyLang.g:18382:1: rule__IndexedColumn__AscAssignment_2_0 : ( ( 'asc' ) ) ;
    public final void rule__IndexedColumn__AscAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18386:1: ( ( ( 'asc' ) ) )
            // InternalMickeyLang.g:18387:2: ( ( 'asc' ) )
            {
            // InternalMickeyLang.g:18387:2: ( ( 'asc' ) )
            // InternalMickeyLang.g:18388:3: ( 'asc' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getAscAscKeyword_2_0_0()); 
            }
            // InternalMickeyLang.g:18389:3: ( 'asc' )
            // InternalMickeyLang.g:18390:4: 'asc'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getAscAscKeyword_2_0_0()); 
            }
            match(input,124,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getAscAscKeyword_2_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getAscAscKeyword_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__AscAssignment_2_0"


    // $ANTLR start "rule__IndexedColumn__DescAssignment_2_1"
    // InternalMickeyLang.g:18401:1: rule__IndexedColumn__DescAssignment_2_1 : ( ( 'desc' ) ) ;
    public final void rule__IndexedColumn__DescAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18405:1: ( ( ( 'desc' ) ) )
            // InternalMickeyLang.g:18406:2: ( ( 'desc' ) )
            {
            // InternalMickeyLang.g:18406:2: ( ( 'desc' ) )
            // InternalMickeyLang.g:18407:3: ( 'desc' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getDescDescKeyword_2_1_0()); 
            }
            // InternalMickeyLang.g:18408:3: ( 'desc' )
            // InternalMickeyLang.g:18409:4: 'desc'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIndexedColumnAccess().getDescDescKeyword_2_1_0()); 
            }
            match(input,125,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getDescDescKeyword_2_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIndexedColumnAccess().getDescDescKeyword_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IndexedColumn__DescAssignment_2_1"


    // $ANTLR start "rule__DefaultValue__LiteralAssignment_0_1"
    // InternalMickeyLang.g:18420:1: rule__DefaultValue__LiteralAssignment_0_1 : ( ruleLiteralValue ) ;
    public final void rule__DefaultValue__LiteralAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18424:1: ( ( ruleLiteralValue ) )
            // InternalMickeyLang.g:18425:2: ( ruleLiteralValue )
            {
            // InternalMickeyLang.g:18425:2: ( ruleLiteralValue )
            // InternalMickeyLang.g:18426:3: ruleLiteralValue
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getLiteralLiteralValueParserRuleCall_0_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleLiteralValue();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getLiteralLiteralValueParserRuleCall_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__LiteralAssignment_0_1"


    // $ANTLR start "rule__DefaultValue__ExpressionAssignment_1_2"
    // InternalMickeyLang.g:18435:1: rule__DefaultValue__ExpressionAssignment_1_2 : ( ruleSqlExpression ) ;
    public final void rule__DefaultValue__ExpressionAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18439:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18440:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18440:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18441:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDefaultValueAccess().getExpressionSqlExpressionParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDefaultValueAccess().getExpressionSqlExpressionParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultValue__ExpressionAssignment_1_2"


    // $ANTLR start "rule__ConflictClause__ResolutionAssignment_2"
    // InternalMickeyLang.g:18450:1: rule__ConflictClause__ResolutionAssignment_2 : ( ruleConflictResolution ) ;
    public final void rule__ConflictClause__ResolutionAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18454:1: ( ( ruleConflictResolution ) )
            // InternalMickeyLang.g:18455:2: ( ruleConflictResolution )
            {
            // InternalMickeyLang.g:18455:2: ( ruleConflictResolution )
            // InternalMickeyLang.g:18456:3: ruleConflictResolution
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConflictClauseAccess().getResolutionConflictResolutionEnumRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictResolution();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConflictClauseAccess().getResolutionConflictResolutionEnumRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConflictClause__ResolutionAssignment_2"


    // $ANTLR start "rule__DeleteStatement__TableAssignment_2"
    // InternalMickeyLang.g:18465:1: rule__DeleteStatement__TableAssignment_2 : ( ( RULE_ID ) ) ;
    public final void rule__DeleteStatement__TableAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18469:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18470:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18470:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18471:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }
            // InternalMickeyLang.g:18472:3: ( RULE_ID )
            // InternalMickeyLang.g:18473:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__TableAssignment_2"


    // $ANTLR start "rule__DeleteStatement__ExpressionAssignment_3_1"
    // InternalMickeyLang.g:18484:1: rule__DeleteStatement__ExpressionAssignment_3_1 : ( ruleSqlExpression ) ;
    public final void rule__DeleteStatement__ExpressionAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18488:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18489:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18489:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18490:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDeleteStatementAccess().getExpressionSqlExpressionParserRuleCall_3_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDeleteStatementAccess().getExpressionSqlExpressionParserRuleCall_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DeleteStatement__ExpressionAssignment_3_1"


    // $ANTLR start "rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1"
    // InternalMickeyLang.g:18499:1: rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1 : ( ruleConflictResolution ) ;
    public final void rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18503:1: ( ( ruleConflictResolution ) )
            // InternalMickeyLang.g:18504:2: ( ruleConflictResolution )
            {
            // InternalMickeyLang.g:18504:2: ( ruleConflictResolution )
            // InternalMickeyLang.g:18505:3: ruleConflictResolution
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getConflictResolutionConflictResolutionEnumRuleCall_0_0_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictResolution();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getConflictResolutionConflictResolutionEnumRuleCall_0_0_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__ConflictResolutionAssignment_0_0_1_1"


    // $ANTLR start "rule__InsertStatement__TableAssignment_2"
    // InternalMickeyLang.g:18514:1: rule__InsertStatement__TableAssignment_2 : ( ( RULE_ID ) ) ;
    public final void rule__InsertStatement__TableAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18518:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18519:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18519:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18520:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }
            // InternalMickeyLang.g:18521:3: ( RULE_ID )
            // InternalMickeyLang.g:18522:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__TableAssignment_2"


    // $ANTLR start "rule__InsertStatement__ColumnNamesAssignment_3_1"
    // InternalMickeyLang.g:18533:1: rule__InsertStatement__ColumnNamesAssignment_3_1 : ( ( RULE_ID ) ) ;
    public final void rule__InsertStatement__ColumnNamesAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18537:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18538:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18538:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18539:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefCrossReference_3_1_0()); 
            }
            // InternalMickeyLang.g:18540:3: ( RULE_ID )
            // InternalMickeyLang.g:18541:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefIDTerminalRuleCall_3_1_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefIDTerminalRuleCall_3_1_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefCrossReference_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__ColumnNamesAssignment_3_1"


    // $ANTLR start "rule__InsertStatement__ColumnNamesAssignment_3_2_1"
    // InternalMickeyLang.g:18552:1: rule__InsertStatement__ColumnNamesAssignment_3_2_1 : ( ( RULE_ID ) ) ;
    public final void rule__InsertStatement__ColumnNamesAssignment_3_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18556:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18557:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18557:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18558:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefCrossReference_3_2_1_0()); 
            }
            // InternalMickeyLang.g:18559:3: ( RULE_ID )
            // InternalMickeyLang.g:18560:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefIDTerminalRuleCall_3_2_1_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefIDTerminalRuleCall_3_2_1_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getColumnNamesColumnDefCrossReference_3_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__ColumnNamesAssignment_3_2_1"


    // $ANTLR start "rule__InsertStatement__ExpressionsAssignment_4_0_0_2"
    // InternalMickeyLang.g:18571:1: rule__InsertStatement__ExpressionsAssignment_4_0_0_2 : ( ruleSqlExpression ) ;
    public final void rule__InsertStatement__ExpressionsAssignment_4_0_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18575:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18576:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18576:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18577:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getExpressionsSqlExpressionParserRuleCall_4_0_0_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getExpressionsSqlExpressionParserRuleCall_4_0_0_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__ExpressionsAssignment_4_0_0_2"


    // $ANTLR start "rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1"
    // InternalMickeyLang.g:18586:1: rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1 : ( ruleSqlExpression ) ;
    public final void rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18590:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18591:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18591:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18592:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getExpressionsSqlExpressionParserRuleCall_4_0_0_3_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getExpressionsSqlExpressionParserRuleCall_4_0_0_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__ExpressionsAssignment_4_0_0_3_1"


    // $ANTLR start "rule__InsertStatement__SelectStatementAssignment_4_0_1"
    // InternalMickeyLang.g:18601:1: rule__InsertStatement__SelectStatementAssignment_4_0_1 : ( ruleSelectStatement ) ;
    public final void rule__InsertStatement__SelectStatementAssignment_4_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18605:1: ( ( ruleSelectStatement ) )
            // InternalMickeyLang.g:18606:2: ( ruleSelectStatement )
            {
            // InternalMickeyLang.g:18606:2: ( ruleSelectStatement )
            // InternalMickeyLang.g:18607:3: ruleSelectStatement
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInsertStatementAccess().getSelectStatementSelectStatementParserRuleCall_4_0_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSelectStatement();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInsertStatementAccess().getSelectStatementSelectStatementParserRuleCall_4_0_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InsertStatement__SelectStatementAssignment_4_0_1"


    // $ANTLR start "rule__UpdateStatement__ConflictResolutionAssignment_1_1"
    // InternalMickeyLang.g:18616:1: rule__UpdateStatement__ConflictResolutionAssignment_1_1 : ( ruleConflictResolution ) ;
    public final void rule__UpdateStatement__ConflictResolutionAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18620:1: ( ( ruleConflictResolution ) )
            // InternalMickeyLang.g:18621:2: ( ruleConflictResolution )
            {
            // InternalMickeyLang.g:18621:2: ( ruleConflictResolution )
            // InternalMickeyLang.g:18622:3: ruleConflictResolution
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getConflictResolutionConflictResolutionEnumRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConflictResolution();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getConflictResolutionConflictResolutionEnumRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__ConflictResolutionAssignment_1_1"


    // $ANTLR start "rule__UpdateStatement__TableAssignment_2"
    // InternalMickeyLang.g:18631:1: rule__UpdateStatement__TableAssignment_2 : ( ( RULE_ID ) ) ;
    public final void rule__UpdateStatement__TableAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18635:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18636:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18636:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18637:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }
            // InternalMickeyLang.g:18638:3: ( RULE_ID )
            // InternalMickeyLang.g:18639:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getTableTableDefinitionIDTerminalRuleCall_2_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getTableTableDefinitionCrossReference_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__TableAssignment_2"


    // $ANTLR start "rule__UpdateStatement__UpdateColumnExpressionsAssignment_4"
    // InternalMickeyLang.g:18650:1: rule__UpdateStatement__UpdateColumnExpressionsAssignment_4 : ( ruleUpdateColumnExpression ) ;
    public final void rule__UpdateStatement__UpdateColumnExpressionsAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18654:1: ( ( ruleUpdateColumnExpression ) )
            // InternalMickeyLang.g:18655:2: ( ruleUpdateColumnExpression )
            {
            // InternalMickeyLang.g:18655:2: ( ruleUpdateColumnExpression )
            // InternalMickeyLang.g:18656:3: ruleUpdateColumnExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsUpdateColumnExpressionParserRuleCall_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleUpdateColumnExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsUpdateColumnExpressionParserRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__UpdateColumnExpressionsAssignment_4"


    // $ANTLR start "rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1"
    // InternalMickeyLang.g:18665:1: rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1 : ( ruleUpdateColumnExpression ) ;
    public final void rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18669:1: ( ( ruleUpdateColumnExpression ) )
            // InternalMickeyLang.g:18670:2: ( ruleUpdateColumnExpression )
            {
            // InternalMickeyLang.g:18670:2: ( ruleUpdateColumnExpression )
            // InternalMickeyLang.g:18671:3: ruleUpdateColumnExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsUpdateColumnExpressionParserRuleCall_5_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleUpdateColumnExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getUpdateColumnExpressionsUpdateColumnExpressionParserRuleCall_5_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__UpdateColumnExpressionsAssignment_5_1"


    // $ANTLR start "rule__UpdateStatement__WhereExpressionAssignment_6_1"
    // InternalMickeyLang.g:18680:1: rule__UpdateStatement__WhereExpressionAssignment_6_1 : ( ruleSqlExpression ) ;
    public final void rule__UpdateStatement__WhereExpressionAssignment_6_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18684:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18685:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18685:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18686:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateStatementAccess().getWhereExpressionSqlExpressionParserRuleCall_6_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateStatementAccess().getWhereExpressionSqlExpressionParserRuleCall_6_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateStatement__WhereExpressionAssignment_6_1"


    // $ANTLR start "rule__UpdateColumnExpression__ColumnNameAssignment_0"
    // InternalMickeyLang.g:18695:1: rule__UpdateColumnExpression__ColumnNameAssignment_0 : ( ( RULE_ID ) ) ;
    public final void rule__UpdateColumnExpression__ColumnNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18699:1: ( ( ( RULE_ID ) ) )
            // InternalMickeyLang.g:18700:2: ( ( RULE_ID ) )
            {
            // InternalMickeyLang.g:18700:2: ( ( RULE_ID ) )
            // InternalMickeyLang.g:18701:3: ( RULE_ID )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameColumnDefCrossReference_0_0()); 
            }
            // InternalMickeyLang.g:18702:3: ( RULE_ID )
            // InternalMickeyLang.g:18703:4: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameColumnDefIDTerminalRuleCall_0_0_1()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameColumnDefIDTerminalRuleCall_0_0_1()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getColumnNameColumnDefCrossReference_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__ColumnNameAssignment_0"


    // $ANTLR start "rule__UpdateColumnExpression__ExpressionAssignment_2"
    // InternalMickeyLang.g:18714:1: rule__UpdateColumnExpression__ExpressionAssignment_2 : ( ruleSqlExpression ) ;
    public final void rule__UpdateColumnExpression__ExpressionAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMickeyLang.g:18718:1: ( ( ruleSqlExpression ) )
            // InternalMickeyLang.g:18719:2: ( ruleSqlExpression )
            {
            // InternalMickeyLang.g:18719:2: ( ruleSqlExpression )
            // InternalMickeyLang.g:18720:3: ruleSqlExpression
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUpdateColumnExpressionAccess().getExpressionSqlExpressionParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleSqlExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUpdateColumnExpressionAccess().getExpressionSqlExpressionParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UpdateColumnExpression__ExpressionAssignment_2"

    // $ANTLR start synpred37_InternalMickeyLang
    public final void synpred37_InternalMickeyLang_fragment() throws RecognitionException {   
        // InternalMickeyLang.g:2228:2: ( ( ( rule__PrimaryExpression__Group_2_1_0__0 ) ) )
        // InternalMickeyLang.g:2228:2: ( ( rule__PrimaryExpression__Group_2_1_0__0 ) )
        {
        // InternalMickeyLang.g:2228:2: ( ( rule__PrimaryExpression__Group_2_1_0__0 ) )
        // InternalMickeyLang.g:2229:3: ( rule__PrimaryExpression__Group_2_1_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1_0()); 
        }
        // InternalMickeyLang.g:2230:3: ( rule__PrimaryExpression__Group_2_1_0__0 )
        // InternalMickeyLang.g:2230:4: rule__PrimaryExpression__Group_2_1_0__0
        {
        pushFollow(FOLLOW_2);
        rule__PrimaryExpression__Group_2_1_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred37_InternalMickeyLang

    // $ANTLR start synpred38_InternalMickeyLang
    public final void synpred38_InternalMickeyLang_fragment() throws RecognitionException {   
        // InternalMickeyLang.g:2234:2: ( ( ( rule__PrimaryExpression__Group_2_1_1__0 ) ) )
        // InternalMickeyLang.g:2234:2: ( ( rule__PrimaryExpression__Group_2_1_1__0 ) )
        {
        // InternalMickeyLang.g:2234:2: ( ( rule__PrimaryExpression__Group_2_1_1__0 ) )
        // InternalMickeyLang.g:2235:3: ( rule__PrimaryExpression__Group_2_1_1__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1_1()); 
        }
        // InternalMickeyLang.g:2236:3: ( rule__PrimaryExpression__Group_2_1_1__0 )
        // InternalMickeyLang.g:2236:4: rule__PrimaryExpression__Group_2_1_1__0
        {
        pushFollow(FOLLOW_2);
        rule__PrimaryExpression__Group_2_1_1__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred38_InternalMickeyLang

    // Delegated rules

    public final boolean synpred37_InternalMickeyLang() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred37_InternalMickeyLang_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred38_InternalMickeyLang() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred38_InternalMickeyLang_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA11 dfa11 = new DFA11(this);
    protected DFA22 dfa22 = new DFA22(this);
    static final String dfa_1s = "\15\uffff";
    static final String dfa_2s = "\3\uffff\1\12\11\uffff";
    static final String dfa_3s = "\1\4\2\uffff\1\14\1\uffff\1\4\7\uffff";
    static final String dfa_4s = "\1\u0086\2\uffff\1\u0082\1\uffff\1\u0086\7\uffff";
    static final String dfa_5s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\uffff\1\6\1\7\1\11\1\12\1\3\1\10\1\5";
    static final String dfa_6s = "\15\uffff}>";
    static final String[] dfa_7s = {
            "\1\4\1\3\1\4\11\uffff\1\4\55\uffff\1\5\14\uffff\1\1\1\2\1\uffff\1\7\2\uffff\1\10\1\uffff\1\11\44\uffff\2\6\11\uffff\4\4",
            "",
            "",
            "\35\12\4\uffff\4\12\14\uffff\1\12\1\13\1\12\3\uffff\2\12\3\uffff\3\12\2\uffff\1\12\1\uffff\2\12\1\uffff\1\12\1\uffff\4\12\1\uffff\5\12\3\uffff\1\12\1\uffff\1\12\2\uffff\1\12\13\uffff\1\12\3\uffff\2\12\4\uffff\4\12\1\uffff\2\12",
            "",
            "\3\14\11\uffff\1\14\55\uffff\1\14\14\uffff\2\14\1\uffff\1\14\2\uffff\1\14\1\uffff\1\14\4\uffff\1\6\37\uffff\2\14\11\uffff\4\14",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
    static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s);
    static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
    static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s);
    static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
    static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
    static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);

    class DFA11 extends DFA {

        public DFA11(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 11;
            this.eot = dfa_1;
            this.eof = dfa_2;
            this.min = dfa_3;
            this.max = dfa_4;
            this.accept = dfa_5;
            this.special = dfa_6;
            this.transition = dfa_7;
        }
        public String getDescription() {
            return "2154:1: rule__PrimaryExpression__Alternatives : ( ( ( rule__PrimaryExpression__Group_0__0 ) ) | ( ( rule__PrimaryExpression__Group_1__0 ) ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) | ( ( rule__PrimaryExpression__Group_3__0 ) ) | ( ( rule__PrimaryExpression__Group_4__0 ) ) | ( ( rule__PrimaryExpression__Group_5__0 ) ) | ( ( rule__PrimaryExpression__Group_6__0 ) ) | ( ( rule__PrimaryExpression__Group_7__0 ) ) | ( ( rule__PrimaryExpression__Group_8__0 ) ) | ( ( rule__PrimaryExpression__Group_9__0 ) ) );";
        }
    }
    static final String dfa_8s = "\21\uffff";
    static final String dfa_9s = "\1\135\3\136\1\uffff\1\136\3\uffff\1\5\4\uffff\1\144\2\uffff";
    static final String dfa_10s = "\1\146\1\u0087\1\136\1\147\1\uffff\1\140\3\uffff\1\5\4\uffff\1\145\2\uffff";
    static final String dfa_11s = "\4\uffff\1\4\1\uffff\1\3\1\2\1\1\1\uffff\1\10\1\7\1\12\1\11\1\uffff\1\6\1\5";
    static final String dfa_12s = "\21\uffff}>";
    static final String[] dfa_13s = {
            "\1\1\5\uffff\1\2\2\uffff\1\3",
            "\1\10\1\7\1\6\6\uffff\1\4\1\uffff\1\4\35\uffff\1\5",
            "\1\11",
            "\1\13\1\15\1\12\6\uffff\1\14",
            "",
            "\1\10\1\7\1\6",
            "",
            "",
            "",
            "\1\16",
            "",
            "",
            "",
            "",
            "\1\20\1\17",
            "",
            ""
    };

    static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s);
    static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
    static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s);
    static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
    static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
    static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);

    class DFA22 extends DFA {

        public DFA22(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 22;
            this.eot = dfa_8;
            this.eof = dfa_8;
            this.min = dfa_9;
            this.max = dfa_10;
            this.accept = dfa_11;
            this.special = dfa_12;
            this.transition = dfa_13;
        }
        public String getDescription() {
            return "2475:1: rule__DDLStatement__Alternatives : ( ( ruleCreateTableStatement ) | ( ruleCreateViewStatement ) | ( ruleCreateTriggerStatement ) | ( ruleCreateIndexStatement ) | ( ruleAlterTableRenameStatement ) | ( ruleAlterTableAddColumnStatement ) | ( ruleDropTableStatement ) | ( ruleDropTriggerStatement ) | ( ruleDropViewStatement ) | ( ruleDropIndexStatement ) );";
        }
    }
 

    public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x2000000000000000L,0x0000004820000110L});
    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x2000000000000002L,0x0000004820000110L});
    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x809E000000000000L});
    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000005L});
    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000100000000000L,0x0012800001000002L});
    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000100000000002L,0x0012800001000000L});
    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000010000000000L});
    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000010000000002L});
    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x009E000000000000L});
    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000002020L,0x0000000000000001L});
    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000001L});
    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000000L,0x00000000000000C2L});
    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000002002L});
    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000020L,0x0000000000000001L});
    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000200000020L});
    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000201L});
    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000000L,0x0000004820000002L});
    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000002L,0x0000004820000000L});
    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0040000000000000L});
    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000002L,0x0040000000000000L});
    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x4000000000010070L,0x03000000000A5800L,0x0000000000000078L});
    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000007000L});
    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000007002L});
    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000018000L});
    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000018002L});
    public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x00000000001E0000L});
    public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x00000000001E0002L});
    public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000001E00000L});
    public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000001E00002L});
    public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000001FFE000000L});
    public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000001FFE000002L});
    public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0080000000000000L});
    public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000002L,0x0080000000000000L});
    public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L});
    public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000002L,0x0004000000000000L});
    public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000006000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000001020L});
    public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000010050L,0x0000000000000000L,0x0000000000000078L});
    public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x4000000000000000L,0x0300000000000000L});
    public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
    public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x4000000000010070L,0x03000000001A5800L,0x0000000000000078L});
    public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0000000000018000L});
    public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x4000000000010072L,0x03000000001A5800L,0x0000000000000078L});
    public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x4000000000011070L,0x03000000000A5800L,0x0000000000000078L});
    public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
    public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x007E000000000000L});
    public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
    public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000C00000L});
    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000018000000000L});
    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0001E00000000000L});
    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0001E00000000002L});
    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x4000000000011070L,0x0F000000000A5800L,0x0000000000000078L});
    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000000000L,0x000000000E000200L});
    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x4000000000000020L});
    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x3000000000000000L});
    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0xC000000010000000L,0x0000000000000006L});
    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000002L,0xC000000010000000L,0x0000000000000006L});
    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000010010L});
    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x8000010000000000L});
    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000000L,0x00001B0000000000L});
    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x00000E0000000000L,0x0012800000000000L});
    public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000000200100000L,0x0000000000000100L});
    public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000100000000000L,0x0012800001008000L});
    public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
    public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000100000000000L,0x0012800001000000L});
    public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
    public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L});
    public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L});
    public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000000000000020L,0x0000000000000000L,0x0000000000000200L});
    public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});
    public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000000000L,0x0000028000000000L});
    public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L});
    public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000002000000000L,0x00000F0000000000L});
    public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000002000000002L,0x00000F0000000000L});
    public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L});
    public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0000000000000000L,0x3000000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x4000000000010050L,0x0000000000000000L,0x0000000000000078L});
    public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000000000000000L,0x0000120000000000L});
    public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000000000000000L,0x0000110000000000L});
    public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000000000000000L,0x3000200000000000L});
    public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0F00100000000000L});
    public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
    public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});
    public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000000000000L,0x0001000000000000L});
    public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x4000000000000000L,0x0008040001000000L});
    public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L});
    public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000000000020L,0x0004000000000000L});
    public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
    public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000010000000000L,0x0000000002000000L});
    public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L});

}