package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
import java.util.Map;
import java.util.HashMap;

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 org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings("all")
public class InternalSolverLanguageParser extends AbstractInternalContentAssistParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "Containment", "Functional", "Abstract", "Contains", "Datatype", "Maximize", "Minimize", "Opposite", "Default", "Extends", "Problem", "Unknown", "Extern", "Import", "Object", "Refers", "Class", "Count", "Empty", "Error", "False", "Scope", "Else", "Enum", "Root", "Then", "True", "FullStopFullStopFullStop", "Inf", "Let", "ExclamationMarkEqualsSign", "HyphenMinusGreaterThanSign", "ColonHyphenMinus", "ColonColon", "ColonEqualsSign", "LessThanSignEqualsSign", "EqualsSignEqualsSign", "EqualsSignGreaterThanSign", "GreaterThanSignEqualsSign", "As", "If", "In", "ExclamationMark", "LeftParenthesis", "RightParenthesis", "Asterisk", "PlusSign", "Comma", "HyphenMinus", "FullStop", "Solidus", "Colon", "Semicolon", "LessThanSign", "EqualsSign", "GreaterThanSign", "QuestionMark", "LeftSquareBracket", "RightSquareBracket", "CircumflexAccent", "LeftCurlyBracket", "VerticalLine", "RightCurlyBracket", "Tilde", "RULE_STRING", "RULE_QUOTED_ID", "RULE_SL_COMMENT", "RULE_TRANSITIVE_CLOSURE", "RULE_REFLEXIVE_TRANSITIVE_CLOSURE", "RULE_FULL_STOP", "RULE_ID", "RULE_INT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER"
    };
    public static final int Enum=27;
    public static final int Import=17;
    public static final int EqualsSignGreaterThanSign=41;
    public static final int True=30;
    public static final int Count=21;
    public static final int False=24;
    public static final int FullStopFullStopFullStop=31;
    public static final int LessThanSign=57;
    public static final int Datatype=8;
    public static final int LeftParenthesis=47;
    public static final int Unknown=15;
    public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=72;
    public static final int Then=29;
    public static final int Extends=13;
    public static final int RightSquareBracket=62;
    public static final int ExclamationMark=46;
    public static final int Opposite=11;
    public static final int GreaterThanSign=59;
    public static final int Root=28;
    public static final int RULE_ID=74;
    public static final int RULE_QUOTED_ID=69;
    public static final int RightParenthesis=48;
    public static final int ColonEqualsSign=38;
    public static final int GreaterThanSignEqualsSign=42;
    public static final int Functional=5;
    public static final int ColonColon=37;
    public static final int EqualsSignEqualsSign=40;
    public static final int VerticalLine=65;
    public static final int PlusSign=50;
    public static final int RULE_INT=75;
    public static final int Contains=7;
    public static final int RULE_ML_COMMENT=76;
    public static final int RULE_TRANSITIVE_CLOSURE=71;
    public static final int Problem=14;
    public static final int Object=18;
    public static final int Class=20;
    public static final int LeftSquareBracket=61;
    public static final int RULE_FULL_STOP=73;
    public static final int If=44;
    public static final int Refers=19;
    public static final int Inf=32;
    public static final int In=45;
    public static final int RULE_STRING=68;
    public static final int Extern=16;
    public static final int RULE_SL_COMMENT=70;
    public static final int Comma=51;
    public static final int EqualsSign=58;
    public static final int Empty=22;
    public static final int As=43;
    public static final int HyphenMinus=52;
    public static final int Maximize=9;
    public static final int LessThanSignEqualsSign=39;
    public static final int Solidus=54;
    public static final int Colon=55;
    public static final int RightCurlyBracket=66;
    public static final int EOF=-1;
    public static final int Asterisk=49;
    public static final int Containment=4;
    public static final int FullStop=53;
    public static final int RULE_WS=77;
    public static final int Abstract=6;
    public static final int Minimize=10;
    public static final int LeftCurlyBracket=64;
    public static final int Error=23;
    public static final int Tilde=67;
    public static final int RULE_ANY_OTHER=78;
    public static final int Default=12;
    public static final int ColonHyphenMinus=36;
    public static final int CircumflexAccent=63;
    public static final int Semicolon=56;
    public static final int Scope=25;
    public static final int QuestionMark=60;
    public static final int Else=26;
    public static final int Let=33;
    public static final int ExclamationMarkEqualsSign=34;
    public static final int HyphenMinusGreaterThanSign=35;

    // delegates
    // delegators


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

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


    	private SolverLanguageGrammarAccess grammarAccess;
    	private final Map<String, String> tokenNameToValue = new HashMap<String, String>();
    	
    	{
    		tokenNameToValue.put("ExclamationMark", "'!'");
    		tokenNameToValue.put("LeftParenthesis", "'('");
    		tokenNameToValue.put("RightParenthesis", "')'");
    		tokenNameToValue.put("Asterisk", "'*'");
    		tokenNameToValue.put("PlusSign", "'+'");
    		tokenNameToValue.put("Comma", "','");
    		tokenNameToValue.put("HyphenMinus", "'-'");
    		tokenNameToValue.put("FullStop", "'.'");
    		tokenNameToValue.put("Solidus", "'/'");
    		tokenNameToValue.put("Colon", "':'");
    		tokenNameToValue.put("Semicolon", "';'");
    		tokenNameToValue.put("LessThanSign", "'<'");
    		tokenNameToValue.put("EqualsSign", "'='");
    		tokenNameToValue.put("GreaterThanSign", "'>'");
    		tokenNameToValue.put("QuestionMark", "'?'");
    		tokenNameToValue.put("LeftSquareBracket", "'['");
    		tokenNameToValue.put("RightSquareBracket", "']'");
    		tokenNameToValue.put("CircumflexAccent", "'^'");
    		tokenNameToValue.put("LeftCurlyBracket", "'{'");
    		tokenNameToValue.put("VerticalLine", "'|'");
    		tokenNameToValue.put("RightCurlyBracket", "'}'");
    		tokenNameToValue.put("Tilde", "'~'");
    		tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='");
    		tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'");
    		tokenNameToValue.put("ColonHyphenMinus", "':-'");
    		tokenNameToValue.put("ColonColon", "'::'");
    		tokenNameToValue.put("ColonEqualsSign", "':='");
    		tokenNameToValue.put("LessThanSignEqualsSign", "'<='");
    		tokenNameToValue.put("EqualsSignEqualsSign", "'=='");
    		tokenNameToValue.put("EqualsSignGreaterThanSign", "'=>'");
    		tokenNameToValue.put("GreaterThanSignEqualsSign", "'>='");
    		tokenNameToValue.put("As", "'as'");
    		tokenNameToValue.put("If", "'if'");
    		tokenNameToValue.put("In", "'in'");
    		tokenNameToValue.put("FullStopFullStopFullStop", "'...'");
    		tokenNameToValue.put("Inf", "'inf'");
    		tokenNameToValue.put("Let", "'let'");
    		tokenNameToValue.put("Else", "'else'");
    		tokenNameToValue.put("Enum", "'enum'");
    		tokenNameToValue.put("Root", "'root'");
    		tokenNameToValue.put("Then", "'then'");
    		tokenNameToValue.put("True", "'true'");
    		tokenNameToValue.put("Class", "'class'");
    		tokenNameToValue.put("Count", "'count'");
    		tokenNameToValue.put("Empty", "'empty'");
    		tokenNameToValue.put("Error", "'error'");
    		tokenNameToValue.put("False", "'false'");
    		tokenNameToValue.put("Scope", "'scope'");
    		tokenNameToValue.put("Extern", "'extern'");
    		tokenNameToValue.put("Import", "'import'");
    		tokenNameToValue.put("Object", "'object'");
    		tokenNameToValue.put("Refers", "'refers'");
    		tokenNameToValue.put("Default", "'default'");
    		tokenNameToValue.put("Extends", "'extends'");
    		tokenNameToValue.put("Problem", "'problem'");
    		tokenNameToValue.put("Unknown", "'unknown'");
    		tokenNameToValue.put("Abstract", "'abstract'");
    		tokenNameToValue.put("Contains", "'contains'");
    		tokenNameToValue.put("Datatype", "'datatype'");
    		tokenNameToValue.put("Maximize", "'maximize'");
    		tokenNameToValue.put("Minimize", "'minimize'");
    		tokenNameToValue.put("Opposite", "'opposite'");
    		tokenNameToValue.put("Functional", "'functional'");
    		tokenNameToValue.put("Containment", "'containment'");
    	}

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

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

    	@Override
    	protected String getValueForTokenName(String tokenName) {
    		String result = tokenNameToValue.get(tokenName);
    		if (result == null)
    			result = tokenName;
    		return result;
    	}



    // $ANTLR start "entryRuleProblem"
    // InternalSolverLanguageParser.g:119:1: entryRuleProblem : ruleProblem EOF ;
    public final void entryRuleProblem() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:120:1: ( ruleProblem EOF )
            // InternalSolverLanguageParser.g:121:1: ruleProblem EOF
            {
             before(grammarAccess.getProblemRule()); 
            pushFollow(FOLLOW_1);
            ruleProblem();

            state._fsp--;

             after(grammarAccess.getProblemRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleProblem"
    // InternalSolverLanguageParser.g:128:1: ruleProblem : ( ( rule__Problem__Group__0 ) ) ;
    public final void ruleProblem() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:132:2: ( ( ( rule__Problem__Group__0 ) ) )
            // InternalSolverLanguageParser.g:133:2: ( ( rule__Problem__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:133:2: ( ( rule__Problem__Group__0 ) )
            // InternalSolverLanguageParser.g:134:3: ( rule__Problem__Group__0 )
            {
             before(grammarAccess.getProblemAccess().getGroup()); 
            // InternalSolverLanguageParser.g:135:3: ( rule__Problem__Group__0 )
            // InternalSolverLanguageParser.g:135:4: rule__Problem__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Problem__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getProblemAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleStatement"
    // InternalSolverLanguageParser.g:144:1: entryRuleStatement : ruleStatement EOF ;
    public final void entryRuleStatement() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:145:1: ( ruleStatement EOF )
            // InternalSolverLanguageParser.g:146:1: ruleStatement EOF
            {
             before(grammarAccess.getStatementRule()); 
            pushFollow(FOLLOW_1);
            ruleStatement();

            state._fsp--;

             after(grammarAccess.getStatementRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleStatement"
    // InternalSolverLanguageParser.g:153:1: ruleStatement : ( ( rule__Statement__Alternatives ) ) ;
    public final void ruleStatement() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:157:2: ( ( ( rule__Statement__Alternatives ) ) )
            // InternalSolverLanguageParser.g:158:2: ( ( rule__Statement__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:158:2: ( ( rule__Statement__Alternatives ) )
            // InternalSolverLanguageParser.g:159:3: ( rule__Statement__Alternatives )
            {
             before(grammarAccess.getStatementAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:160:3: ( rule__Statement__Alternatives )
            // InternalSolverLanguageParser.g:160:4: rule__Statement__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__Statement__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getStatementAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleImport"
    // InternalSolverLanguageParser.g:169:1: entryRuleImport : ruleImport EOF ;
    public final void entryRuleImport() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:170:1: ( ruleImport EOF )
            // InternalSolverLanguageParser.g:171:1: ruleImport EOF
            {
             before(grammarAccess.getImportRule()); 
            pushFollow(FOLLOW_1);
            ruleImport();

            state._fsp--;

             after(grammarAccess.getImportRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleImport"
    // InternalSolverLanguageParser.g:178:1: ruleImport : ( ( rule__Import__Alternatives ) ) ;
    public final void ruleImport() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:182:2: ( ( ( rule__Import__Alternatives ) ) )
            // InternalSolverLanguageParser.g:183:2: ( ( rule__Import__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:183:2: ( ( rule__Import__Alternatives ) )
            // InternalSolverLanguageParser.g:184:3: ( rule__Import__Alternatives )
            {
             before(grammarAccess.getImportAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:185:3: ( rule__Import__Alternatives )
            // InternalSolverLanguageParser.g:185:4: rule__Import__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__Import__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getImportAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleUriImport"
    // InternalSolverLanguageParser.g:194:1: entryRuleUriImport : ruleUriImport EOF ;
    public final void entryRuleUriImport() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:195:1: ( ruleUriImport EOF )
            // InternalSolverLanguageParser.g:196:1: ruleUriImport EOF
            {
             before(grammarAccess.getUriImportRule()); 
            pushFollow(FOLLOW_1);
            ruleUriImport();

            state._fsp--;

             after(grammarAccess.getUriImportRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleUriImport"
    // InternalSolverLanguageParser.g:203:1: ruleUriImport : ( ( rule__UriImport__Group__0 ) ) ;
    public final void ruleUriImport() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:207:2: ( ( ( rule__UriImport__Group__0 ) ) )
            // InternalSolverLanguageParser.g:208:2: ( ( rule__UriImport__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:208:2: ( ( rule__UriImport__Group__0 ) )
            // InternalSolverLanguageParser.g:209:3: ( rule__UriImport__Group__0 )
            {
             before(grammarAccess.getUriImportAccess().getGroup()); 
            // InternalSolverLanguageParser.g:210:3: ( rule__UriImport__Group__0 )
            // InternalSolverLanguageParser.g:210:4: rule__UriImport__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__UriImport__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getUriImportAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleNamespaceImport"
    // InternalSolverLanguageParser.g:219:1: entryRuleNamespaceImport : ruleNamespaceImport EOF ;
    public final void entryRuleNamespaceImport() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:220:1: ( ruleNamespaceImport EOF )
            // InternalSolverLanguageParser.g:221:1: ruleNamespaceImport EOF
            {
             before(grammarAccess.getNamespaceImportRule()); 
            pushFollow(FOLLOW_1);
            ruleNamespaceImport();

            state._fsp--;

             after(grammarAccess.getNamespaceImportRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleNamespaceImport"
    // InternalSolverLanguageParser.g:228:1: ruleNamespaceImport : ( ( rule__NamespaceImport__Group__0 ) ) ;
    public final void ruleNamespaceImport() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:232:2: ( ( ( rule__NamespaceImport__Group__0 ) ) )
            // InternalSolverLanguageParser.g:233:2: ( ( rule__NamespaceImport__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:233:2: ( ( rule__NamespaceImport__Group__0 ) )
            // InternalSolverLanguageParser.g:234:3: ( rule__NamespaceImport__Group__0 )
            {
             before(grammarAccess.getNamespaceImportAccess().getGroup()); 
            // InternalSolverLanguageParser.g:235:3: ( rule__NamespaceImport__Group__0 )
            // InternalSolverLanguageParser.g:235:4: rule__NamespaceImport__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getNamespaceImportAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAssertionOrDefinition"
    // InternalSolverLanguageParser.g:244:1: entryRuleAssertionOrDefinition : ruleAssertionOrDefinition EOF ;
    public final void entryRuleAssertionOrDefinition() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:245:1: ( ruleAssertionOrDefinition EOF )
            // InternalSolverLanguageParser.g:246:1: ruleAssertionOrDefinition EOF
            {
             before(grammarAccess.getAssertionOrDefinitionRule()); 
            pushFollow(FOLLOW_1);
            ruleAssertionOrDefinition();

            state._fsp--;

             after(grammarAccess.getAssertionOrDefinitionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleAssertionOrDefinition"
    // InternalSolverLanguageParser.g:253:1: ruleAssertionOrDefinition : ( ( rule__AssertionOrDefinition__Group__0 ) ) ;
    public final void ruleAssertionOrDefinition() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:257:2: ( ( ( rule__AssertionOrDefinition__Group__0 ) ) )
            // InternalSolverLanguageParser.g:258:2: ( ( rule__AssertionOrDefinition__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:258:2: ( ( rule__AssertionOrDefinition__Group__0 ) )
            // InternalSolverLanguageParser.g:259:3: ( rule__AssertionOrDefinition__Group__0 )
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:260:3: ( rule__AssertionOrDefinition__Group__0 )
            // InternalSolverLanguageParser.g:260:4: rule__AssertionOrDefinition__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePredicateDefinition"
    // InternalSolverLanguageParser.g:269:1: entryRulePredicateDefinition : rulePredicateDefinition EOF ;
    public final void entryRulePredicateDefinition() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:270:1: ( rulePredicateDefinition EOF )
            // InternalSolverLanguageParser.g:271:1: rulePredicateDefinition EOF
            {
             before(grammarAccess.getPredicateDefinitionRule()); 
            pushFollow(FOLLOW_1);
            rulePredicateDefinition();

            state._fsp--;

             after(grammarAccess.getPredicateDefinitionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "rulePredicateDefinition"
    // InternalSolverLanguageParser.g:278:1: rulePredicateDefinition : ( ( rule__PredicateDefinition__Group__0 ) ) ;
    public final void rulePredicateDefinition() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:282:2: ( ( ( rule__PredicateDefinition__Group__0 ) ) )
            // InternalSolverLanguageParser.g:283:2: ( ( rule__PredicateDefinition__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:283:2: ( ( rule__PredicateDefinition__Group__0 ) )
            // InternalSolverLanguageParser.g:284:3: ( rule__PredicateDefinition__Group__0 )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:285:3: ( rule__PredicateDefinition__Group__0 )
            // InternalSolverLanguageParser.g:285:4: rule__PredicateDefinition__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getPredicateDefinitionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleUnnamedErrorPredicateDefintion"
    // InternalSolverLanguageParser.g:294:1: entryRuleUnnamedErrorPredicateDefintion : ruleUnnamedErrorPredicateDefintion EOF ;
    public final void entryRuleUnnamedErrorPredicateDefintion() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:295:1: ( ruleUnnamedErrorPredicateDefintion EOF )
            // InternalSolverLanguageParser.g:296:1: ruleUnnamedErrorPredicateDefintion EOF
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionRule()); 
            pushFollow(FOLLOW_1);
            ruleUnnamedErrorPredicateDefintion();

            state._fsp--;

             after(grammarAccess.getUnnamedErrorPredicateDefintionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleUnnamedErrorPredicateDefintion"
    // InternalSolverLanguageParser.g:303:1: ruleUnnamedErrorPredicateDefintion : ( ( rule__UnnamedErrorPredicateDefintion__Group__0 ) ) ;
    public final void ruleUnnamedErrorPredicateDefintion() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:307:2: ( ( ( rule__UnnamedErrorPredicateDefintion__Group__0 ) ) )
            // InternalSolverLanguageParser.g:308:2: ( ( rule__UnnamedErrorPredicateDefintion__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:308:2: ( ( rule__UnnamedErrorPredicateDefintion__Group__0 ) )
            // InternalSolverLanguageParser.g:309:3: ( rule__UnnamedErrorPredicateDefintion__Group__0 )
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:310:3: ( rule__UnnamedErrorPredicateDefintion__Group__0 )
            // InternalSolverLanguageParser.g:310:4: rule__UnnamedErrorPredicateDefintion__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleDefaultAssertion"
    // InternalSolverLanguageParser.g:319:1: entryRuleDefaultAssertion : ruleDefaultAssertion EOF ;
    public final void entryRuleDefaultAssertion() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:320:1: ( ruleDefaultAssertion EOF )
            // InternalSolverLanguageParser.g:321:1: ruleDefaultAssertion EOF
            {
             before(grammarAccess.getDefaultAssertionRule()); 
            pushFollow(FOLLOW_1);
            ruleDefaultAssertion();

            state._fsp--;

             after(grammarAccess.getDefaultAssertionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleDefaultAssertion"
    // InternalSolverLanguageParser.g:328:1: ruleDefaultAssertion : ( ( rule__DefaultAssertion__Group__0 ) ) ;
    public final void ruleDefaultAssertion() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:332:2: ( ( ( rule__DefaultAssertion__Group__0 ) ) )
            // InternalSolverLanguageParser.g:333:2: ( ( rule__DefaultAssertion__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:333:2: ( ( rule__DefaultAssertion__Group__0 ) )
            // InternalSolverLanguageParser.g:334:3: ( rule__DefaultAssertion__Group__0 )
            {
             before(grammarAccess.getDefaultAssertionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:335:3: ( rule__DefaultAssertion__Group__0 )
            // InternalSolverLanguageParser.g:335:4: rule__DefaultAssertion__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getDefaultAssertionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleFunctionDefinition"
    // InternalSolverLanguageParser.g:344:1: entryRuleFunctionDefinition : ruleFunctionDefinition EOF ;
    public final void entryRuleFunctionDefinition() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:345:1: ( ruleFunctionDefinition EOF )
            // InternalSolverLanguageParser.g:346:1: ruleFunctionDefinition EOF
            {
             before(grammarAccess.getFunctionDefinitionRule()); 
            pushFollow(FOLLOW_1);
            ruleFunctionDefinition();

            state._fsp--;

             after(grammarAccess.getFunctionDefinitionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleFunctionDefinition"
    // InternalSolverLanguageParser.g:353:1: ruleFunctionDefinition : ( ( rule__FunctionDefinition__Group__0 ) ) ;
    public final void ruleFunctionDefinition() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:357:2: ( ( ( rule__FunctionDefinition__Group__0 ) ) )
            // InternalSolverLanguageParser.g:358:2: ( ( rule__FunctionDefinition__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:358:2: ( ( rule__FunctionDefinition__Group__0 ) )
            // InternalSolverLanguageParser.g:359:3: ( rule__FunctionDefinition__Group__0 )
            {
             before(grammarAccess.getFunctionDefinitionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:360:3: ( rule__FunctionDefinition__Group__0 )
            // InternalSolverLanguageParser.g:360:4: rule__FunctionDefinition__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getFunctionDefinitionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleTypeReference"
    // InternalSolverLanguageParser.g:369:1: entryRuleTypeReference : ruleTypeReference EOF ;
    public final void entryRuleTypeReference() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:370:1: ( ruleTypeReference EOF )
            // InternalSolverLanguageParser.g:371:1: ruleTypeReference EOF
            {
             before(grammarAccess.getTypeReferenceRule()); 
            pushFollow(FOLLOW_1);
            ruleTypeReference();

            state._fsp--;

             after(grammarAccess.getTypeReferenceRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleTypeReference"
    // InternalSolverLanguageParser.g:378:1: ruleTypeReference : ( ( rule__TypeReference__Group__0 ) ) ;
    public final void ruleTypeReference() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:382:2: ( ( ( rule__TypeReference__Group__0 ) ) )
            // InternalSolverLanguageParser.g:383:2: ( ( rule__TypeReference__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:383:2: ( ( rule__TypeReference__Group__0 ) )
            // InternalSolverLanguageParser.g:384:3: ( rule__TypeReference__Group__0 )
            {
             before(grammarAccess.getTypeReferenceAccess().getGroup()); 
            // InternalSolverLanguageParser.g:385:3: ( rule__TypeReference__Group__0 )
            // InternalSolverLanguageParser.g:385:4: rule__TypeReference__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__TypeReference__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getTypeReferenceAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAttribute"
    // InternalSolverLanguageParser.g:394:1: entryRuleAttribute : ruleAttribute EOF ;
    public final void entryRuleAttribute() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:395:1: ( ruleAttribute EOF )
            // InternalSolverLanguageParser.g:396:1: ruleAttribute EOF
            {
             before(grammarAccess.getAttributeRule()); 
            pushFollow(FOLLOW_1);
            ruleAttribute();

            state._fsp--;

             after(grammarAccess.getAttributeRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleAttribute"
    // InternalSolverLanguageParser.g:403:1: ruleAttribute : ( ( rule__Attribute__Group__0 ) ) ;
    public final void ruleAttribute() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:407:2: ( ( ( rule__Attribute__Group__0 ) ) )
            // InternalSolverLanguageParser.g:408:2: ( ( rule__Attribute__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:408:2: ( ( rule__Attribute__Group__0 ) )
            // InternalSolverLanguageParser.g:409:3: ( rule__Attribute__Group__0 )
            {
             before(grammarAccess.getAttributeAccess().getGroup()); 
            // InternalSolverLanguageParser.g:410:3: ( rule__Attribute__Group__0 )
            // InternalSolverLanguageParser.g:410:4: rule__Attribute__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Attribute__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getAttributeAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExternDeclaration"
    // InternalSolverLanguageParser.g:419:1: entryRuleExternDeclaration : ruleExternDeclaration EOF ;
    public final void entryRuleExternDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:420:1: ( ruleExternDeclaration EOF )
            // InternalSolverLanguageParser.g:421:1: ruleExternDeclaration EOF
            {
             before(grammarAccess.getExternDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleExternDeclaration();

            state._fsp--;

             after(grammarAccess.getExternDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExternDeclaration"
    // InternalSolverLanguageParser.g:428:1: ruleExternDeclaration : ( ( rule__ExternDeclaration__Alternatives ) ) ;
    public final void ruleExternDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:432:2: ( ( ( rule__ExternDeclaration__Alternatives ) ) )
            // InternalSolverLanguageParser.g:433:2: ( ( rule__ExternDeclaration__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:433:2: ( ( rule__ExternDeclaration__Alternatives ) )
            // InternalSolverLanguageParser.g:434:3: ( rule__ExternDeclaration__Alternatives )
            {
             before(grammarAccess.getExternDeclarationAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:435:3: ( rule__ExternDeclaration__Alternatives )
            // InternalSolverLanguageParser.g:435:4: rule__ExternDeclaration__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ExternDeclaration__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getExternDeclarationAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExternPredicateDeclaration"
    // InternalSolverLanguageParser.g:444:1: entryRuleExternPredicateDeclaration : ruleExternPredicateDeclaration EOF ;
    public final void entryRuleExternPredicateDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:445:1: ( ruleExternPredicateDeclaration EOF )
            // InternalSolverLanguageParser.g:446:1: ruleExternPredicateDeclaration EOF
            {
             before(grammarAccess.getExternPredicateDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleExternPredicateDeclaration();

            state._fsp--;

             after(grammarAccess.getExternPredicateDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExternPredicateDeclaration"
    // InternalSolverLanguageParser.g:453:1: ruleExternPredicateDeclaration : ( ( rule__ExternPredicateDeclaration__Group__0 ) ) ;
    public final void ruleExternPredicateDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:457:2: ( ( ( rule__ExternPredicateDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:458:2: ( ( rule__ExternPredicateDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:458:2: ( ( rule__ExternPredicateDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:459:3: ( rule__ExternPredicateDeclaration__Group__0 )
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:460:3: ( rule__ExternPredicateDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:460:4: rule__ExternPredicateDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExternPredicateDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExternFunctionDeclaration"
    // InternalSolverLanguageParser.g:469:1: entryRuleExternFunctionDeclaration : ruleExternFunctionDeclaration EOF ;
    public final void entryRuleExternFunctionDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:470:1: ( ruleExternFunctionDeclaration EOF )
            // InternalSolverLanguageParser.g:471:1: ruleExternFunctionDeclaration EOF
            {
             before(grammarAccess.getExternFunctionDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleExternFunctionDeclaration();

            state._fsp--;

             after(grammarAccess.getExternFunctionDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExternFunctionDeclaration"
    // InternalSolverLanguageParser.g:478:1: ruleExternFunctionDeclaration : ( ( rule__ExternFunctionDeclaration__Group__0 ) ) ;
    public final void ruleExternFunctionDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:482:2: ( ( ( rule__ExternFunctionDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:483:2: ( ( rule__ExternFunctionDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:483:2: ( ( rule__ExternFunctionDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:484:3: ( rule__ExternFunctionDeclaration__Group__0 )
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:485:3: ( rule__ExternFunctionDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:485:4: rule__ExternFunctionDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExternFunctionDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExternAggregationOperatorDeclaration"
    // InternalSolverLanguageParser.g:494:1: entryRuleExternAggregationOperatorDeclaration : ruleExternAggregationOperatorDeclaration EOF ;
    public final void entryRuleExternAggregationOperatorDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:495:1: ( ruleExternAggregationOperatorDeclaration EOF )
            // InternalSolverLanguageParser.g:496:1: ruleExternAggregationOperatorDeclaration EOF
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleExternAggregationOperatorDeclaration();

            state._fsp--;

             after(grammarAccess.getExternAggregationOperatorDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExternAggregationOperatorDeclaration"
    // InternalSolverLanguageParser.g:503:1: ruleExternAggregationOperatorDeclaration : ( ( rule__ExternAggregationOperatorDeclaration__Group__0 ) ) ;
    public final void ruleExternAggregationOperatorDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:507:2: ( ( ( rule__ExternAggregationOperatorDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:508:2: ( ( rule__ExternAggregationOperatorDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:508:2: ( ( rule__ExternAggregationOperatorDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:509:3: ( rule__ExternAggregationOperatorDeclaration__Group__0 )
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:510:3: ( rule__ExternAggregationOperatorDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:510:4: rule__ExternAggregationOperatorDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExternDatatypeDeclaration"
    // InternalSolverLanguageParser.g:519:1: entryRuleExternDatatypeDeclaration : ruleExternDatatypeDeclaration EOF ;
    public final void entryRuleExternDatatypeDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:520:1: ( ruleExternDatatypeDeclaration EOF )
            // InternalSolverLanguageParser.g:521:1: ruleExternDatatypeDeclaration EOF
            {
             before(grammarAccess.getExternDatatypeDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleExternDatatypeDeclaration();

            state._fsp--;

             after(grammarAccess.getExternDatatypeDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExternDatatypeDeclaration"
    // InternalSolverLanguageParser.g:528:1: ruleExternDatatypeDeclaration : ( ( rule__ExternDatatypeDeclaration__Group__0 ) ) ;
    public final void ruleExternDatatypeDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:532:2: ( ( ( rule__ExternDatatypeDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:533:2: ( ( rule__ExternDatatypeDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:533:2: ( ( rule__ExternDatatypeDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:534:3: ( rule__ExternDatatypeDeclaration__Group__0 )
            {
             before(grammarAccess.getExternDatatypeDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:535:3: ( rule__ExternDatatypeDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:535:4: rule__ExternDatatypeDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExternDatatypeDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExternDatatypeDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExpression"
    // InternalSolverLanguageParser.g:544:1: entryRuleExpression : ruleExpression EOF ;
    public final void entryRuleExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:545:1: ( ruleExpression EOF )
            // InternalSolverLanguageParser.g:546:1: ruleExpression EOF
            {
             before(grammarAccess.getExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExpression"
    // InternalSolverLanguageParser.g:553:1: ruleExpression : ( ( rule__Expression__Alternatives ) ) ;
    public final void ruleExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:557:2: ( ( ( rule__Expression__Alternatives ) ) )
            // InternalSolverLanguageParser.g:558:2: ( ( rule__Expression__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:558:2: ( ( rule__Expression__Alternatives ) )
            // InternalSolverLanguageParser.g:559:3: ( rule__Expression__Alternatives )
            {
             before(grammarAccess.getExpressionAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:560:3: ( rule__Expression__Alternatives )
            // InternalSolverLanguageParser.g:560:4: rule__Expression__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__Expression__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getExpressionAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleConditionalExpression"
    // InternalSolverLanguageParser.g:569:1: entryRuleConditionalExpression : ruleConditionalExpression EOF ;
    public final void entryRuleConditionalExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:570:1: ( ruleConditionalExpression EOF )
            // InternalSolverLanguageParser.g:571:1: ruleConditionalExpression EOF
            {
             before(grammarAccess.getConditionalExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleConditionalExpression();

            state._fsp--;

             after(grammarAccess.getConditionalExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleConditionalExpression"
    // InternalSolverLanguageParser.g:578:1: ruleConditionalExpression : ( ( rule__ConditionalExpression__Group__0 ) ) ;
    public final void ruleConditionalExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:582:2: ( ( ( rule__ConditionalExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:583:2: ( ( rule__ConditionalExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:583:2: ( ( rule__ConditionalExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:584:3: ( rule__ConditionalExpression__Group__0 )
            {
             before(grammarAccess.getConditionalExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:585:3: ( rule__ConditionalExpression__Group__0 )
            // InternalSolverLanguageParser.g:585:4: rule__ConditionalExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getConditionalExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLetExpression"
    // InternalSolverLanguageParser.g:594:1: entryRuleLetExpression : ruleLetExpression EOF ;
    public final void entryRuleLetExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:595:1: ( ruleLetExpression EOF )
            // InternalSolverLanguageParser.g:596:1: ruleLetExpression EOF
            {
             before(grammarAccess.getLetExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleLetExpression();

            state._fsp--;

             after(grammarAccess.getLetExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleLetExpression"
    // InternalSolverLanguageParser.g:603:1: ruleLetExpression : ( ( rule__LetExpression__Group__0 ) ) ;
    public final void ruleLetExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:607:2: ( ( ( rule__LetExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:608:2: ( ( rule__LetExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:608:2: ( ( rule__LetExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:609:3: ( rule__LetExpression__Group__0 )
            {
             before(grammarAccess.getLetExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:610:3: ( rule__LetExpression__Group__0 )
            // InternalSolverLanguageParser.g:610:4: rule__LetExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__LetExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getLetExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLetBinding"
    // InternalSolverLanguageParser.g:619:1: entryRuleLetBinding : ruleLetBinding EOF ;
    public final void entryRuleLetBinding() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:620:1: ( ruleLetBinding EOF )
            // InternalSolverLanguageParser.g:621:1: ruleLetBinding EOF
            {
             before(grammarAccess.getLetBindingRule()); 
            pushFollow(FOLLOW_1);
            ruleLetBinding();

            state._fsp--;

             after(grammarAccess.getLetBindingRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleLetBinding"
    // InternalSolverLanguageParser.g:628:1: ruleLetBinding : ( ( rule__LetBinding__Group__0 ) ) ;
    public final void ruleLetBinding() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:632:2: ( ( ( rule__LetBinding__Group__0 ) ) )
            // InternalSolverLanguageParser.g:633:2: ( ( rule__LetBinding__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:633:2: ( ( rule__LetBinding__Group__0 ) )
            // InternalSolverLanguageParser.g:634:3: ( rule__LetBinding__Group__0 )
            {
             before(grammarAccess.getLetBindingAccess().getGroup()); 
            // InternalSolverLanguageParser.g:635:3: ( rule__LetBinding__Group__0 )
            // InternalSolverLanguageParser.g:635:4: rule__LetBinding__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__LetBinding__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getLetBindingAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleDisjunctiveExpression"
    // InternalSolverLanguageParser.g:644:1: entryRuleDisjunctiveExpression : ruleDisjunctiveExpression EOF ;
    public final void entryRuleDisjunctiveExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:645:1: ( ruleDisjunctiveExpression EOF )
            // InternalSolverLanguageParser.g:646:1: ruleDisjunctiveExpression EOF
            {
             before(grammarAccess.getDisjunctiveExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleDisjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getDisjunctiveExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleDisjunctiveExpression"
    // InternalSolverLanguageParser.g:653:1: ruleDisjunctiveExpression : ( ( rule__DisjunctiveExpression__Group__0 ) ) ;
    public final void ruleDisjunctiveExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:657:2: ( ( ( rule__DisjunctiveExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:658:2: ( ( rule__DisjunctiveExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:658:2: ( ( rule__DisjunctiveExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:659:3: ( rule__DisjunctiveExpression__Group__0 )
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:660:3: ( rule__DisjunctiveExpression__Group__0 )
            // InternalSolverLanguageParser.g:660:4: rule__DisjunctiveExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCase"
    // InternalSolverLanguageParser.g:669:1: entryRuleCase : ruleCase EOF ;
    public final void entryRuleCase() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:670:1: ( ruleCase EOF )
            // InternalSolverLanguageParser.g:671:1: ruleCase EOF
            {
             before(grammarAccess.getCaseRule()); 
            pushFollow(FOLLOW_1);
            ruleCase();

            state._fsp--;

             after(grammarAccess.getCaseRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:682:2: ( ( ( rule__Case__Group__0 ) ) )
            // InternalSolverLanguageParser.g:683:2: ( ( rule__Case__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:683:2: ( ( rule__Case__Group__0 ) )
            // InternalSolverLanguageParser.g:684:3: ( rule__Case__Group__0 )
            {
             before(grammarAccess.getCaseAccess().getGroup()); 
            // InternalSolverLanguageParser.g:685:3: ( rule__Case__Group__0 )
            // InternalSolverLanguageParser.g:685:4: rule__Case__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Case__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getCaseAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleConjunctiveExpression"
    // InternalSolverLanguageParser.g:694:1: entryRuleConjunctiveExpression : ruleConjunctiveExpression EOF ;
    public final void entryRuleConjunctiveExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:695:1: ( ruleConjunctiveExpression EOF )
            // InternalSolverLanguageParser.g:696:1: ruleConjunctiveExpression EOF
            {
             before(grammarAccess.getConjunctiveExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleConjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getConjunctiveExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleConjunctiveExpression"
    // InternalSolverLanguageParser.g:703:1: ruleConjunctiveExpression : ( ( rule__ConjunctiveExpression__Group__0 ) ) ;
    public final void ruleConjunctiveExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:707:2: ( ( ( rule__ConjunctiveExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:708:2: ( ( rule__ConjunctiveExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:708:2: ( ( rule__ConjunctiveExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:709:3: ( rule__ConjunctiveExpression__Group__0 )
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:710:3: ( rule__ConjunctiveExpression__Group__0 )
            // InternalSolverLanguageParser.g:710:4: rule__ConjunctiveExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getConjunctiveExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleComparisonExpression"
    // InternalSolverLanguageParser.g:719:1: entryRuleComparisonExpression : ruleComparisonExpression EOF ;
    public final void entryRuleComparisonExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:720:1: ( ruleComparisonExpression EOF )
            // InternalSolverLanguageParser.g:721:1: ruleComparisonExpression EOF
            {
             before(grammarAccess.getComparisonExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleComparisonExpression();

            state._fsp--;

             after(grammarAccess.getComparisonExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleComparisonExpression"
    // InternalSolverLanguageParser.g:728:1: ruleComparisonExpression : ( ( rule__ComparisonExpression__Group__0 ) ) ;
    public final void ruleComparisonExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:732:2: ( ( ( rule__ComparisonExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:733:2: ( ( rule__ComparisonExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:733:2: ( ( rule__ComparisonExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:734:3: ( rule__ComparisonExpression__Group__0 )
            {
             before(grammarAccess.getComparisonExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:735:3: ( rule__ComparisonExpression__Group__0 )
            // InternalSolverLanguageParser.g:735:4: rule__ComparisonExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getComparisonExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAdditiveExpression"
    // InternalSolverLanguageParser.g:744:1: entryRuleAdditiveExpression : ruleAdditiveExpression EOF ;
    public final void entryRuleAdditiveExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:745:1: ( ruleAdditiveExpression EOF )
            // InternalSolverLanguageParser.g:746:1: ruleAdditiveExpression EOF
            {
             before(grammarAccess.getAdditiveExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleAdditiveExpression();

            state._fsp--;

             after(grammarAccess.getAdditiveExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleAdditiveExpression"
    // InternalSolverLanguageParser.g:753:1: ruleAdditiveExpression : ( ( rule__AdditiveExpression__Group__0 ) ) ;
    public final void ruleAdditiveExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:757:2: ( ( ( rule__AdditiveExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:758:2: ( ( rule__AdditiveExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:758:2: ( ( rule__AdditiveExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:759:3: ( rule__AdditiveExpression__Group__0 )
            {
             before(grammarAccess.getAdditiveExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:760:3: ( rule__AdditiveExpression__Group__0 )
            // InternalSolverLanguageParser.g:760:4: rule__AdditiveExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getAdditiveExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleMultiplicativeExpression"
    // InternalSolverLanguageParser.g:769:1: entryRuleMultiplicativeExpression : ruleMultiplicativeExpression EOF ;
    public final void entryRuleMultiplicativeExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:770:1: ( ruleMultiplicativeExpression EOF )
            // InternalSolverLanguageParser.g:771:1: ruleMultiplicativeExpression EOF
            {
             before(grammarAccess.getMultiplicativeExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleMultiplicativeExpression();

            state._fsp--;

             after(grammarAccess.getMultiplicativeExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleMultiplicativeExpression"
    // InternalSolverLanguageParser.g:778:1: ruleMultiplicativeExpression : ( ( rule__MultiplicativeExpression__Group__0 ) ) ;
    public final void ruleMultiplicativeExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:782:2: ( ( ( rule__MultiplicativeExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:783:2: ( ( rule__MultiplicativeExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:783:2: ( ( rule__MultiplicativeExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:784:3: ( rule__MultiplicativeExpression__Group__0 )
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:785:3: ( rule__MultiplicativeExpression__Group__0 )
            // InternalSolverLanguageParser.g:785:4: rule__MultiplicativeExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExponentialExpression"
    // InternalSolverLanguageParser.g:794:1: entryRuleExponentialExpression : ruleExponentialExpression EOF ;
    public final void entryRuleExponentialExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:795:1: ( ruleExponentialExpression EOF )
            // InternalSolverLanguageParser.g:796:1: ruleExponentialExpression EOF
            {
             before(grammarAccess.getExponentialExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleExponentialExpression();

            state._fsp--;

             after(grammarAccess.getExponentialExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExponentialExpression"
    // InternalSolverLanguageParser.g:803:1: ruleExponentialExpression : ( ( rule__ExponentialExpression__Group__0 ) ) ;
    public final void ruleExponentialExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:807:2: ( ( ( rule__ExponentialExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:808:2: ( ( rule__ExponentialExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:808:2: ( ( rule__ExponentialExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:809:3: ( rule__ExponentialExpression__Group__0 )
            {
             before(grammarAccess.getExponentialExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:810:3: ( rule__ExponentialExpression__Group__0 )
            // InternalSolverLanguageParser.g:810:4: rule__ExponentialExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExponentialExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCastExpression"
    // InternalSolverLanguageParser.g:819:1: entryRuleCastExpression : ruleCastExpression EOF ;
    public final void entryRuleCastExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:820:1: ( ruleCastExpression EOF )
            // InternalSolverLanguageParser.g:821:1: ruleCastExpression EOF
            {
             before(grammarAccess.getCastExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleCastExpression();

            state._fsp--;

             after(grammarAccess.getCastExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleCastExpression"
    // InternalSolverLanguageParser.g:828:1: ruleCastExpression : ( ( rule__CastExpression__Group__0 ) ) ;
    public final void ruleCastExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:832:2: ( ( ( rule__CastExpression__Group__0 ) ) )
            // InternalSolverLanguageParser.g:833:2: ( ( rule__CastExpression__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:833:2: ( ( rule__CastExpression__Group__0 ) )
            // InternalSolverLanguageParser.g:834:3: ( rule__CastExpression__Group__0 )
            {
             before(grammarAccess.getCastExpressionAccess().getGroup()); 
            // InternalSolverLanguageParser.g:835:3: ( rule__CastExpression__Group__0 )
            // InternalSolverLanguageParser.g:835:4: rule__CastExpression__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CastExpression__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getCastExpressionAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleUnaryExpression"
    // InternalSolverLanguageParser.g:844:1: entryRuleUnaryExpression : ruleUnaryExpression EOF ;
    public final void entryRuleUnaryExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:845:1: ( ruleUnaryExpression EOF )
            // InternalSolverLanguageParser.g:846:1: ruleUnaryExpression EOF
            {
             before(grammarAccess.getUnaryExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleUnaryExpression();

            state._fsp--;

             after(grammarAccess.getUnaryExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleUnaryExpression"
    // InternalSolverLanguageParser.g:853:1: ruleUnaryExpression : ( ( rule__UnaryExpression__Alternatives ) ) ;
    public final void ruleUnaryExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:857:2: ( ( ( rule__UnaryExpression__Alternatives ) ) )
            // InternalSolverLanguageParser.g:858:2: ( ( rule__UnaryExpression__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:858:2: ( ( rule__UnaryExpression__Alternatives ) )
            // InternalSolverLanguageParser.g:859:3: ( rule__UnaryExpression__Alternatives )
            {
             before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:860:3: ( rule__UnaryExpression__Alternatives )
            // InternalSolverLanguageParser.g:860:4: rule__UnaryExpression__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__UnaryExpression__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleBracedAggregateExpression"
    // InternalSolverLanguageParser.g:869:1: entryRuleBracedAggregateExpression : ruleBracedAggregateExpression EOF ;
    public final void entryRuleBracedAggregateExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:870:1: ( ruleBracedAggregateExpression EOF )
            // InternalSolverLanguageParser.g:871:1: ruleBracedAggregateExpression EOF
            {
             before(grammarAccess.getBracedAggregateExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleBracedAggregateExpression();

            state._fsp--;

             after(grammarAccess.getBracedAggregateExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleBracedAggregateExpression"
    // InternalSolverLanguageParser.g:878:1: ruleBracedAggregateExpression : ( ( rule__BracedAggregateExpression__Alternatives ) ) ;
    public final void ruleBracedAggregateExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:882:2: ( ( ( rule__BracedAggregateExpression__Alternatives ) ) )
            // InternalSolverLanguageParser.g:883:2: ( ( rule__BracedAggregateExpression__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:883:2: ( ( rule__BracedAggregateExpression__Alternatives ) )
            // InternalSolverLanguageParser.g:884:3: ( rule__BracedAggregateExpression__Alternatives )
            {
             before(grammarAccess.getBracedAggregateExpressionAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:885:3: ( rule__BracedAggregateExpression__Alternatives )
            // InternalSolverLanguageParser.g:885:4: rule__BracedAggregateExpression__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__BracedAggregateExpression__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getBracedAggregateExpressionAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAggregation"
    // InternalSolverLanguageParser.g:894:1: entryRuleAggregation : ruleAggregation EOF ;
    public final void entryRuleAggregation() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:895:1: ( ruleAggregation EOF )
            // InternalSolverLanguageParser.g:896:1: ruleAggregation EOF
            {
             before(grammarAccess.getAggregationRule()); 
            pushFollow(FOLLOW_1);
            ruleAggregation();

            state._fsp--;

             after(grammarAccess.getAggregationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleAggregation"
    // InternalSolverLanguageParser.g:903:1: ruleAggregation : ( ( rule__Aggregation__Group__0 ) ) ;
    public final void ruleAggregation() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:907:2: ( ( ( rule__Aggregation__Group__0 ) ) )
            // InternalSolverLanguageParser.g:908:2: ( ( rule__Aggregation__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:908:2: ( ( rule__Aggregation__Group__0 ) )
            // InternalSolverLanguageParser.g:909:3: ( rule__Aggregation__Group__0 )
            {
             before(grammarAccess.getAggregationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:910:3: ( rule__Aggregation__Group__0 )
            // InternalSolverLanguageParser.g:910:4: rule__Aggregation__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getAggregationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCount"
    // InternalSolverLanguageParser.g:919:1: entryRuleCount : ruleCount EOF ;
    public final void entryRuleCount() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:920:1: ( ruleCount EOF )
            // InternalSolverLanguageParser.g:921:1: ruleCount EOF
            {
             before(grammarAccess.getCountRule()); 
            pushFollow(FOLLOW_1);
            ruleCount();

            state._fsp--;

             after(grammarAccess.getCountRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleCount"
    // InternalSolverLanguageParser.g:928:1: ruleCount : ( ( rule__Count__Group__0 ) ) ;
    public final void ruleCount() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:932:2: ( ( ( rule__Count__Group__0 ) ) )
            // InternalSolverLanguageParser.g:933:2: ( ( rule__Count__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:933:2: ( ( rule__Count__Group__0 ) )
            // InternalSolverLanguageParser.g:934:3: ( rule__Count__Group__0 )
            {
             before(grammarAccess.getCountAccess().getGroup()); 
            // InternalSolverLanguageParser.g:935:3: ( rule__Count__Group__0 )
            // InternalSolverLanguageParser.g:935:4: rule__Count__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Count__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getCountAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAtomicExpression"
    // InternalSolverLanguageParser.g:944:1: entryRuleAtomicExpression : ruleAtomicExpression EOF ;
    public final void entryRuleAtomicExpression() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:945:1: ( ruleAtomicExpression EOF )
            // InternalSolverLanguageParser.g:946:1: ruleAtomicExpression EOF
            {
             before(grammarAccess.getAtomicExpressionRule()); 
            pushFollow(FOLLOW_1);
            ruleAtomicExpression();

            state._fsp--;

             after(grammarAccess.getAtomicExpressionRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleAtomicExpression"
    // InternalSolverLanguageParser.g:953:1: ruleAtomicExpression : ( ( rule__AtomicExpression__Alternatives ) ) ;
    public final void ruleAtomicExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:957:2: ( ( ( rule__AtomicExpression__Alternatives ) ) )
            // InternalSolverLanguageParser.g:958:2: ( ( rule__AtomicExpression__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:958:2: ( ( rule__AtomicExpression__Alternatives ) )
            // InternalSolverLanguageParser.g:959:3: ( rule__AtomicExpression__Alternatives )
            {
             before(grammarAccess.getAtomicExpressionAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:960:3: ( rule__AtomicExpression__Alternatives )
            // InternalSolverLanguageParser.g:960:4: rule__AtomicExpression__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__AtomicExpression__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getAtomicExpressionAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCall"
    // InternalSolverLanguageParser.g:969:1: entryRuleCall : ruleCall EOF ;
    public final void entryRuleCall() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:970:1: ( ruleCall EOF )
            // InternalSolverLanguageParser.g:971:1: ruleCall EOF
            {
             before(grammarAccess.getCallRule()); 
            pushFollow(FOLLOW_1);
            ruleCall();

            state._fsp--;

             after(grammarAccess.getCallRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleCall"
    // InternalSolverLanguageParser.g:978:1: ruleCall : ( ( rule__Call__Group__0 ) ) ;
    public final void ruleCall() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:982:2: ( ( ( rule__Call__Group__0 ) ) )
            // InternalSolverLanguageParser.g:983:2: ( ( rule__Call__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:983:2: ( ( rule__Call__Group__0 ) )
            // InternalSolverLanguageParser.g:984:3: ( rule__Call__Group__0 )
            {
             before(grammarAccess.getCallAccess().getGroup()); 
            // InternalSolverLanguageParser.g:985:3: ( rule__Call__Group__0 )
            // InternalSolverLanguageParser.g:985:4: rule__Call__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Call__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getCallAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleArgumentList"
    // InternalSolverLanguageParser.g:994:1: entryRuleArgumentList : ruleArgumentList EOF ;
    public final void entryRuleArgumentList() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:995:1: ( ruleArgumentList EOF )
            // InternalSolverLanguageParser.g:996:1: ruleArgumentList EOF
            {
             before(grammarAccess.getArgumentListRule()); 
            pushFollow(FOLLOW_1);
            ruleArgumentList();

            state._fsp--;

             after(grammarAccess.getArgumentListRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleArgumentList"
    // InternalSolverLanguageParser.g:1003:1: ruleArgumentList : ( ( rule__ArgumentList__Group__0 ) ) ;
    public final void ruleArgumentList() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1007:2: ( ( ( rule__ArgumentList__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1008:2: ( ( rule__ArgumentList__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1008:2: ( ( rule__ArgumentList__Group__0 ) )
            // InternalSolverLanguageParser.g:1009:3: ( rule__ArgumentList__Group__0 )
            {
             before(grammarAccess.getArgumentListAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1010:3: ( rule__ArgumentList__Group__0 )
            // InternalSolverLanguageParser.g:1010:4: rule__ArgumentList__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getArgumentListAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleArgument"
    // InternalSolverLanguageParser.g:1019:1: entryRuleArgument : ruleArgument EOF ;
    public final void entryRuleArgument() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1020:1: ( ruleArgument EOF )
            // InternalSolverLanguageParser.g:1021:1: ruleArgument EOF
            {
             before(grammarAccess.getArgumentRule()); 
            pushFollow(FOLLOW_1);
            ruleArgument();

            state._fsp--;

             after(grammarAccess.getArgumentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleArgument"
    // InternalSolverLanguageParser.g:1028:1: ruleArgument : ( ( rule__Argument__Alternatives ) ) ;
    public final void ruleArgument() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1032:2: ( ( ( rule__Argument__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1033:2: ( ( rule__Argument__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1033:2: ( ( rule__Argument__Alternatives ) )
            // InternalSolverLanguageParser.g:1034:3: ( rule__Argument__Alternatives )
            {
             before(grammarAccess.getArgumentAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1035:3: ( rule__Argument__Alternatives )
            // InternalSolverLanguageParser.g:1035:4: rule__Argument__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__Argument__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getArgumentAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExpressionArgument"
    // InternalSolverLanguageParser.g:1044:1: entryRuleExpressionArgument : ruleExpressionArgument EOF ;
    public final void entryRuleExpressionArgument() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1045:1: ( ruleExpressionArgument EOF )
            // InternalSolverLanguageParser.g:1046:1: ruleExpressionArgument EOF
            {
             before(grammarAccess.getExpressionArgumentRule()); 
            pushFollow(FOLLOW_1);
            ruleExpressionArgument();

            state._fsp--;

             after(grammarAccess.getExpressionArgumentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExpressionArgument"
    // InternalSolverLanguageParser.g:1053:1: ruleExpressionArgument : ( ( rule__ExpressionArgument__ExpressionAssignment ) ) ;
    public final void ruleExpressionArgument() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1057:2: ( ( ( rule__ExpressionArgument__ExpressionAssignment ) ) )
            // InternalSolverLanguageParser.g:1058:2: ( ( rule__ExpressionArgument__ExpressionAssignment ) )
            {
            // InternalSolverLanguageParser.g:1058:2: ( ( rule__ExpressionArgument__ExpressionAssignment ) )
            // InternalSolverLanguageParser.g:1059:3: ( rule__ExpressionArgument__ExpressionAssignment )
            {
             before(grammarAccess.getExpressionArgumentAccess().getExpressionAssignment()); 
            // InternalSolverLanguageParser.g:1060:3: ( rule__ExpressionArgument__ExpressionAssignment )
            // InternalSolverLanguageParser.g:1060:4: rule__ExpressionArgument__ExpressionAssignment
            {
            pushFollow(FOLLOW_2);
            rule__ExpressionArgument__ExpressionAssignment();

            state._fsp--;


            }

             after(grammarAccess.getExpressionArgumentAccess().getExpressionAssignment()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleStarArgument"
    // InternalSolverLanguageParser.g:1069:1: entryRuleStarArgument : ruleStarArgument EOF ;
    public final void entryRuleStarArgument() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1070:1: ( ruleStarArgument EOF )
            // InternalSolverLanguageParser.g:1071:1: ruleStarArgument EOF
            {
             before(grammarAccess.getStarArgumentRule()); 
            pushFollow(FOLLOW_1);
            ruleStarArgument();

            state._fsp--;

             after(grammarAccess.getStarArgumentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleStarArgument"
    // InternalSolverLanguageParser.g:1078:1: ruleStarArgument : ( ( rule__StarArgument__Group__0 ) ) ;
    public final void ruleStarArgument() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1082:2: ( ( ( rule__StarArgument__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1083:2: ( ( rule__StarArgument__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1083:2: ( ( rule__StarArgument__Group__0 ) )
            // InternalSolverLanguageParser.g:1084:3: ( rule__StarArgument__Group__0 )
            {
             before(grammarAccess.getStarArgumentAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1085:3: ( rule__StarArgument__Group__0 )
            // InternalSolverLanguageParser.g:1085:4: rule__StarArgument__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__StarArgument__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getStarArgumentAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleTypedVariableArgument"
    // InternalSolverLanguageParser.g:1094:1: entryRuleTypedVariableArgument : ruleTypedVariableArgument EOF ;
    public final void entryRuleTypedVariableArgument() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1095:1: ( ruleTypedVariableArgument EOF )
            // InternalSolverLanguageParser.g:1096:1: ruleTypedVariableArgument EOF
            {
             before(grammarAccess.getTypedVariableArgumentRule()); 
            pushFollow(FOLLOW_1);
            ruleTypedVariableArgument();

            state._fsp--;

             after(grammarAccess.getTypedVariableArgumentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleTypedVariableArgument"
    // InternalSolverLanguageParser.g:1103:1: ruleTypedVariableArgument : ( ( rule__TypedVariableArgument__Group__0 ) ) ;
    public final void ruleTypedVariableArgument() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1107:2: ( ( ( rule__TypedVariableArgument__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1108:2: ( ( rule__TypedVariableArgument__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1108:2: ( ( rule__TypedVariableArgument__Group__0 ) )
            // InternalSolverLanguageParser.g:1109:3: ( rule__TypedVariableArgument__Group__0 )
            {
             before(grammarAccess.getTypedVariableArgumentAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1110:3: ( rule__TypedVariableArgument__Group__0 )
            // InternalSolverLanguageParser.g:1110:4: rule__TypedVariableArgument__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__TypedVariableArgument__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getTypedVariableArgumentAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleTypedStarArgument"
    // InternalSolverLanguageParser.g:1119:1: entryRuleTypedStarArgument : ruleTypedStarArgument EOF ;
    public final void entryRuleTypedStarArgument() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1120:1: ( ruleTypedStarArgument EOF )
            // InternalSolverLanguageParser.g:1121:1: ruleTypedStarArgument EOF
            {
             before(grammarAccess.getTypedStarArgumentRule()); 
            pushFollow(FOLLOW_1);
            ruleTypedStarArgument();

            state._fsp--;

             after(grammarAccess.getTypedStarArgumentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleTypedStarArgument"
    // InternalSolverLanguageParser.g:1128:1: ruleTypedStarArgument : ( ( rule__TypedStarArgument__Group__0 ) ) ;
    public final void ruleTypedStarArgument() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1132:2: ( ( ( rule__TypedStarArgument__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1133:2: ( ( rule__TypedStarArgument__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1133:2: ( ( rule__TypedStarArgument__Group__0 ) )
            // InternalSolverLanguageParser.g:1134:3: ( rule__TypedStarArgument__Group__0 )
            {
             before(grammarAccess.getTypedStarArgumentAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1135:3: ( rule__TypedStarArgument__Group__0 )
            // InternalSolverLanguageParser.g:1135:4: rule__TypedStarArgument__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__TypedStarArgument__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getTypedStarArgumentAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleReference"
    // InternalSolverLanguageParser.g:1144:1: entryRuleReference : ruleReference EOF ;
    public final void entryRuleReference() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1145:1: ( ruleReference EOF )
            // InternalSolverLanguageParser.g:1146:1: ruleReference EOF
            {
             before(grammarAccess.getReferenceRule()); 
            pushFollow(FOLLOW_1);
            ruleReference();

            state._fsp--;

             after(grammarAccess.getReferenceRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleReference"
    // InternalSolverLanguageParser.g:1153:1: ruleReference : ( ( rule__Reference__Group__0 ) ) ;
    public final void ruleReference() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1157:2: ( ( ( rule__Reference__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1158:2: ( ( rule__Reference__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1158:2: ( ( rule__Reference__Group__0 ) )
            // InternalSolverLanguageParser.g:1159:3: ( rule__Reference__Group__0 )
            {
             before(grammarAccess.getReferenceAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1160:3: ( rule__Reference__Group__0 )
            // InternalSolverLanguageParser.g:1160:4: rule__Reference__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Reference__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getReferenceAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePathComponent"
    // InternalSolverLanguageParser.g:1169:1: entryRulePathComponent : rulePathComponent EOF ;
    public final void entryRulePathComponent() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1170:1: ( rulePathComponent EOF )
            // InternalSolverLanguageParser.g:1171:1: rulePathComponent EOF
            {
             before(grammarAccess.getPathComponentRule()); 
            pushFollow(FOLLOW_1);
            rulePathComponent();

            state._fsp--;

             after(grammarAccess.getPathComponentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "rulePathComponent"
    // InternalSolverLanguageParser.g:1178:1: rulePathComponent : ( ( rule__PathComponent__Group__0 ) ) ;
    public final void rulePathComponent() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1182:2: ( ( ( rule__PathComponent__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1183:2: ( ( rule__PathComponent__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1183:2: ( ( rule__PathComponent__Group__0 ) )
            // InternalSolverLanguageParser.g:1184:3: ( rule__PathComponent__Group__0 )
            {
             before(grammarAccess.getPathComponentAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1185:3: ( rule__PathComponent__Group__0 )
            // InternalSolverLanguageParser.g:1185:4: rule__PathComponent__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__PathComponent__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getPathComponentAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleInterval"
    // InternalSolverLanguageParser.g:1194:1: entryRuleInterval : ruleInterval EOF ;
    public final void entryRuleInterval() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1195:1: ( ruleInterval EOF )
            // InternalSolverLanguageParser.g:1196:1: ruleInterval EOF
            {
             before(grammarAccess.getIntervalRule()); 
            pushFollow(FOLLOW_1);
            ruleInterval();

            state._fsp--;

             after(grammarAccess.getIntervalRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleInterval"
    // InternalSolverLanguageParser.g:1203:1: ruleInterval : ( ( rule__Interval__Group__0 ) ) ;
    public final void ruleInterval() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1207:2: ( ( ( rule__Interval__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1208:2: ( ( rule__Interval__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1208:2: ( ( rule__Interval__Group__0 ) )
            // InternalSolverLanguageParser.g:1209:3: ( rule__Interval__Group__0 )
            {
             before(grammarAccess.getIntervalAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1210:3: ( rule__Interval__Group__0 )
            // InternalSolverLanguageParser.g:1210:4: rule__Interval__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Interval__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getIntervalAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLiteral"
    // InternalSolverLanguageParser.g:1219:1: entryRuleLiteral : ruleLiteral EOF ;
    public final void entryRuleLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1220:1: ( ruleLiteral EOF )
            // InternalSolverLanguageParser.g:1221:1: ruleLiteral EOF
            {
             before(grammarAccess.getLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleLiteral();

            state._fsp--;

             after(grammarAccess.getLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleLiteral"
    // InternalSolverLanguageParser.g:1228:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
    public final void ruleLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1232:2: ( ( ( rule__Literal__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1233:2: ( ( rule__Literal__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1233:2: ( ( rule__Literal__Alternatives ) )
            // InternalSolverLanguageParser.g:1234:3: ( rule__Literal__Alternatives )
            {
             before(grammarAccess.getLiteralAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1235:3: ( rule__Literal__Alternatives )
            // InternalSolverLanguageParser.g:1235:4: rule__Literal__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__Literal__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getLiteralAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLogicLiteral"
    // InternalSolverLanguageParser.g:1244:1: entryRuleLogicLiteral : ruleLogicLiteral EOF ;
    public final void entryRuleLogicLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1245:1: ( ruleLogicLiteral EOF )
            // InternalSolverLanguageParser.g:1246:1: ruleLogicLiteral EOF
            {
             before(grammarAccess.getLogicLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleLogicLiteral();

            state._fsp--;

             after(grammarAccess.getLogicLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleLogicLiteral"
    // InternalSolverLanguageParser.g:1253:1: ruleLogicLiteral : ( ( rule__LogicLiteral__ValueAssignment ) ) ;
    public final void ruleLogicLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1257:2: ( ( ( rule__LogicLiteral__ValueAssignment ) ) )
            // InternalSolverLanguageParser.g:1258:2: ( ( rule__LogicLiteral__ValueAssignment ) )
            {
            // InternalSolverLanguageParser.g:1258:2: ( ( rule__LogicLiteral__ValueAssignment ) )
            // InternalSolverLanguageParser.g:1259:3: ( rule__LogicLiteral__ValueAssignment )
            {
             before(grammarAccess.getLogicLiteralAccess().getValueAssignment()); 
            // InternalSolverLanguageParser.g:1260:3: ( rule__LogicLiteral__ValueAssignment )
            // InternalSolverLanguageParser.g:1260:4: rule__LogicLiteral__ValueAssignment
            {
            pushFollow(FOLLOW_2);
            rule__LogicLiteral__ValueAssignment();

            state._fsp--;


            }

             after(grammarAccess.getLogicLiteralAccess().getValueAssignment()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleIntLiteral"
    // InternalSolverLanguageParser.g:1269:1: entryRuleIntLiteral : ruleIntLiteral EOF ;
    public final void entryRuleIntLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1270:1: ( ruleIntLiteral EOF )
            // InternalSolverLanguageParser.g:1271:1: ruleIntLiteral EOF
            {
             before(grammarAccess.getIntLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleIntLiteral();

            state._fsp--;

             after(grammarAccess.getIntLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleIntLiteral"
    // InternalSolverLanguageParser.g:1278:1: ruleIntLiteral : ( ( rule__IntLiteral__ValueAssignment ) ) ;
    public final void ruleIntLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1282:2: ( ( ( rule__IntLiteral__ValueAssignment ) ) )
            // InternalSolverLanguageParser.g:1283:2: ( ( rule__IntLiteral__ValueAssignment ) )
            {
            // InternalSolverLanguageParser.g:1283:2: ( ( rule__IntLiteral__ValueAssignment ) )
            // InternalSolverLanguageParser.g:1284:3: ( rule__IntLiteral__ValueAssignment )
            {
             before(grammarAccess.getIntLiteralAccess().getValueAssignment()); 
            // InternalSolverLanguageParser.g:1285:3: ( rule__IntLiteral__ValueAssignment )
            // InternalSolverLanguageParser.g:1285:4: rule__IntLiteral__ValueAssignment
            {
            pushFollow(FOLLOW_2);
            rule__IntLiteral__ValueAssignment();

            state._fsp--;


            }

             after(grammarAccess.getIntLiteralAccess().getValueAssignment()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleRealLiteral"
    // InternalSolverLanguageParser.g:1294:1: entryRuleRealLiteral : ruleRealLiteral EOF ;
    public final void entryRuleRealLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1295:1: ( ruleRealLiteral EOF )
            // InternalSolverLanguageParser.g:1296:1: ruleRealLiteral EOF
            {
             before(grammarAccess.getRealLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleRealLiteral();

            state._fsp--;

             after(grammarAccess.getRealLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleRealLiteral"
    // InternalSolverLanguageParser.g:1303:1: ruleRealLiteral : ( ( rule__RealLiteral__ValueAssignment ) ) ;
    public final void ruleRealLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1307:2: ( ( ( rule__RealLiteral__ValueAssignment ) ) )
            // InternalSolverLanguageParser.g:1308:2: ( ( rule__RealLiteral__ValueAssignment ) )
            {
            // InternalSolverLanguageParser.g:1308:2: ( ( rule__RealLiteral__ValueAssignment ) )
            // InternalSolverLanguageParser.g:1309:3: ( rule__RealLiteral__ValueAssignment )
            {
             before(grammarAccess.getRealLiteralAccess().getValueAssignment()); 
            // InternalSolverLanguageParser.g:1310:3: ( rule__RealLiteral__ValueAssignment )
            // InternalSolverLanguageParser.g:1310:4: rule__RealLiteral__ValueAssignment
            {
            pushFollow(FOLLOW_2);
            rule__RealLiteral__ValueAssignment();

            state._fsp--;


            }

             after(grammarAccess.getRealLiteralAccess().getValueAssignment()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleInfinityLiteral"
    // InternalSolverLanguageParser.g:1319:1: entryRuleInfinityLiteral : ruleInfinityLiteral EOF ;
    public final void entryRuleInfinityLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1320:1: ( ruleInfinityLiteral EOF )
            // InternalSolverLanguageParser.g:1321:1: ruleInfinityLiteral EOF
            {
             before(grammarAccess.getInfinityLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleInfinityLiteral();

            state._fsp--;

             after(grammarAccess.getInfinityLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleInfinityLiteral"
    // InternalSolverLanguageParser.g:1328:1: ruleInfinityLiteral : ( ( rule__InfinityLiteral__Group__0 ) ) ;
    public final void ruleInfinityLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1332:2: ( ( ( rule__InfinityLiteral__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1333:2: ( ( rule__InfinityLiteral__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1333:2: ( ( rule__InfinityLiteral__Group__0 ) )
            // InternalSolverLanguageParser.g:1334:3: ( rule__InfinityLiteral__Group__0 )
            {
             before(grammarAccess.getInfinityLiteralAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1335:3: ( rule__InfinityLiteral__Group__0 )
            // InternalSolverLanguageParser.g:1335:4: rule__InfinityLiteral__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__InfinityLiteral__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getInfinityLiteralAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleEmptyLiteral"
    // InternalSolverLanguageParser.g:1344:1: entryRuleEmptyLiteral : ruleEmptyLiteral EOF ;
    public final void entryRuleEmptyLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1345:1: ( ruleEmptyLiteral EOF )
            // InternalSolverLanguageParser.g:1346:1: ruleEmptyLiteral EOF
            {
             before(grammarAccess.getEmptyLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleEmptyLiteral();

            state._fsp--;

             after(grammarAccess.getEmptyLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleEmptyLiteral"
    // InternalSolverLanguageParser.g:1353:1: ruleEmptyLiteral : ( ( rule__EmptyLiteral__Group__0 ) ) ;
    public final void ruleEmptyLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1357:2: ( ( ( rule__EmptyLiteral__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1358:2: ( ( rule__EmptyLiteral__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1358:2: ( ( rule__EmptyLiteral__Group__0 ) )
            // InternalSolverLanguageParser.g:1359:3: ( rule__EmptyLiteral__Group__0 )
            {
             before(grammarAccess.getEmptyLiteralAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1360:3: ( rule__EmptyLiteral__Group__0 )
            // InternalSolverLanguageParser.g:1360:4: rule__EmptyLiteral__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__EmptyLiteral__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getEmptyLiteralAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleStringLiteral"
    // InternalSolverLanguageParser.g:1369:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
    public final void entryRuleStringLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1370:1: ( ruleStringLiteral EOF )
            // InternalSolverLanguageParser.g:1371:1: ruleStringLiteral EOF
            {
             before(grammarAccess.getStringLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleStringLiteral();

            state._fsp--;

             after(grammarAccess.getStringLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleStringLiteral"
    // InternalSolverLanguageParser.g:1378:1: ruleStringLiteral : ( ( rule__StringLiteral__ValueAssignment ) ) ;
    public final void ruleStringLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1382:2: ( ( ( rule__StringLiteral__ValueAssignment ) ) )
            // InternalSolverLanguageParser.g:1383:2: ( ( rule__StringLiteral__ValueAssignment ) )
            {
            // InternalSolverLanguageParser.g:1383:2: ( ( rule__StringLiteral__ValueAssignment ) )
            // InternalSolverLanguageParser.g:1384:3: ( rule__StringLiteral__ValueAssignment )
            {
             before(grammarAccess.getStringLiteralAccess().getValueAssignment()); 
            // InternalSolverLanguageParser.g:1385:3: ( rule__StringLiteral__ValueAssignment )
            // InternalSolverLanguageParser.g:1385:4: rule__StringLiteral__ValueAssignment
            {
            pushFollow(FOLLOW_2);
            rule__StringLiteral__ValueAssignment();

            state._fsp--;


            }

             after(grammarAccess.getStringLiteralAccess().getValueAssignment()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleClassDeclaration"
    // InternalSolverLanguageParser.g:1394:1: entryRuleClassDeclaration : ruleClassDeclaration EOF ;
    public final void entryRuleClassDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1395:1: ( ruleClassDeclaration EOF )
            // InternalSolverLanguageParser.g:1396:1: ruleClassDeclaration EOF
            {
             before(grammarAccess.getClassDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleClassDeclaration();

            state._fsp--;

             after(grammarAccess.getClassDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleClassDeclaration"
    // InternalSolverLanguageParser.g:1403:1: ruleClassDeclaration : ( ( rule__ClassDeclaration__Group__0 ) ) ;
    public final void ruleClassDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1407:2: ( ( ( rule__ClassDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1408:2: ( ( rule__ClassDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1408:2: ( ( rule__ClassDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:1409:3: ( rule__ClassDeclaration__Group__0 )
            {
             before(grammarAccess.getClassDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1410:3: ( rule__ClassDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:1410:4: rule__ClassDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getClassDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleField"
    // InternalSolverLanguageParser.g:1419:1: entryRuleField : ruleField EOF ;
    public final void entryRuleField() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1420:1: ( ruleField EOF )
            // InternalSolverLanguageParser.g:1421:1: ruleField EOF
            {
             before(grammarAccess.getFieldRule()); 
            pushFollow(FOLLOW_1);
            ruleField();

            state._fsp--;

             after(grammarAccess.getFieldRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleField"
    // InternalSolverLanguageParser.g:1428:1: ruleField : ( ( rule__Field__Group__0 ) ) ;
    public final void ruleField() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1432:2: ( ( ( rule__Field__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1433:2: ( ( rule__Field__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1433:2: ( ( rule__Field__Group__0 ) )
            // InternalSolverLanguageParser.g:1434:3: ( rule__Field__Group__0 )
            {
             before(grammarAccess.getFieldAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1435:3: ( rule__Field__Group__0 )
            // InternalSolverLanguageParser.g:1435:4: rule__Field__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Field__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getFieldAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleMultiplicity"
    // InternalSolverLanguageParser.g:1444:1: entryRuleMultiplicity : ruleMultiplicity EOF ;
    public final void entryRuleMultiplicity() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1445:1: ( ruleMultiplicity EOF )
            // InternalSolverLanguageParser.g:1446:1: ruleMultiplicity EOF
            {
             before(grammarAccess.getMultiplicityRule()); 
            pushFollow(FOLLOW_1);
            ruleMultiplicity();

            state._fsp--;

             after(grammarAccess.getMultiplicityRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleMultiplicity"
    // InternalSolverLanguageParser.g:1453:1: ruleMultiplicity : ( ( rule__Multiplicity__Alternatives ) ) ;
    public final void ruleMultiplicity() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1457:2: ( ( ( rule__Multiplicity__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1458:2: ( ( rule__Multiplicity__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1458:2: ( ( rule__Multiplicity__Alternatives ) )
            // InternalSolverLanguageParser.g:1459:3: ( rule__Multiplicity__Alternatives )
            {
             before(grammarAccess.getMultiplicityAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1460:3: ( rule__Multiplicity__Alternatives )
            // InternalSolverLanguageParser.g:1460:4: rule__Multiplicity__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__Multiplicity__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getMultiplicityAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleUnboundedMultiplicity"
    // InternalSolverLanguageParser.g:1469:1: entryRuleUnboundedMultiplicity : ruleUnboundedMultiplicity EOF ;
    public final void entryRuleUnboundedMultiplicity() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1470:1: ( ruleUnboundedMultiplicity EOF )
            // InternalSolverLanguageParser.g:1471:1: ruleUnboundedMultiplicity EOF
            {
             before(grammarAccess.getUnboundedMultiplicityRule()); 
            pushFollow(FOLLOW_1);
            ruleUnboundedMultiplicity();

            state._fsp--;

             after(grammarAccess.getUnboundedMultiplicityRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleUnboundedMultiplicity"
    // InternalSolverLanguageParser.g:1478:1: ruleUnboundedMultiplicity : ( ( rule__UnboundedMultiplicity__Group__0 ) ) ;
    public final void ruleUnboundedMultiplicity() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1482:2: ( ( ( rule__UnboundedMultiplicity__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1483:2: ( ( rule__UnboundedMultiplicity__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1483:2: ( ( rule__UnboundedMultiplicity__Group__0 ) )
            // InternalSolverLanguageParser.g:1484:3: ( rule__UnboundedMultiplicity__Group__0 )
            {
             before(grammarAccess.getUnboundedMultiplicityAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1485:3: ( rule__UnboundedMultiplicity__Group__0 )
            // InternalSolverLanguageParser.g:1485:4: rule__UnboundedMultiplicity__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__UnboundedMultiplicity__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getUnboundedMultiplicityAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExactMultiplicity"
    // InternalSolverLanguageParser.g:1494:1: entryRuleExactMultiplicity : ruleExactMultiplicity EOF ;
    public final void entryRuleExactMultiplicity() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1495:1: ( ruleExactMultiplicity EOF )
            // InternalSolverLanguageParser.g:1496:1: ruleExactMultiplicity EOF
            {
             before(grammarAccess.getExactMultiplicityRule()); 
            pushFollow(FOLLOW_1);
            ruleExactMultiplicity();

            state._fsp--;

             after(grammarAccess.getExactMultiplicityRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExactMultiplicity"
    // InternalSolverLanguageParser.g:1503:1: ruleExactMultiplicity : ( ( rule__ExactMultiplicity__Group__0 ) ) ;
    public final void ruleExactMultiplicity() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1507:2: ( ( ( rule__ExactMultiplicity__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1508:2: ( ( rule__ExactMultiplicity__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1508:2: ( ( rule__ExactMultiplicity__Group__0 ) )
            // InternalSolverLanguageParser.g:1509:3: ( rule__ExactMultiplicity__Group__0 )
            {
             before(grammarAccess.getExactMultiplicityAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1510:3: ( rule__ExactMultiplicity__Group__0 )
            // InternalSolverLanguageParser.g:1510:4: rule__ExactMultiplicity__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExactMultiplicity__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExactMultiplicityAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleBoundedMultiplicity"
    // InternalSolverLanguageParser.g:1519:1: entryRuleBoundedMultiplicity : ruleBoundedMultiplicity EOF ;
    public final void entryRuleBoundedMultiplicity() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1520:1: ( ruleBoundedMultiplicity EOF )
            // InternalSolverLanguageParser.g:1521:1: ruleBoundedMultiplicity EOF
            {
             before(grammarAccess.getBoundedMultiplicityRule()); 
            pushFollow(FOLLOW_1);
            ruleBoundedMultiplicity();

            state._fsp--;

             after(grammarAccess.getBoundedMultiplicityRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleBoundedMultiplicity"
    // InternalSolverLanguageParser.g:1528:1: ruleBoundedMultiplicity : ( ( rule__BoundedMultiplicity__Group__0 ) ) ;
    public final void ruleBoundedMultiplicity() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1532:2: ( ( ( rule__BoundedMultiplicity__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1533:2: ( ( rule__BoundedMultiplicity__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1533:2: ( ( rule__BoundedMultiplicity__Group__0 ) )
            // InternalSolverLanguageParser.g:1534:3: ( rule__BoundedMultiplicity__Group__0 )
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1535:3: ( rule__BoundedMultiplicity__Group__0 )
            // InternalSolverLanguageParser.g:1535:4: rule__BoundedMultiplicity__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getBoundedMultiplicityAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleEnumDeclaration"
    // InternalSolverLanguageParser.g:1544:1: entryRuleEnumDeclaration : ruleEnumDeclaration EOF ;
    public final void entryRuleEnumDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1545:1: ( ruleEnumDeclaration EOF )
            // InternalSolverLanguageParser.g:1546:1: ruleEnumDeclaration EOF
            {
             before(grammarAccess.getEnumDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleEnumDeclaration();

            state._fsp--;

             after(grammarAccess.getEnumDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleEnumDeclaration"
    // InternalSolverLanguageParser.g:1553:1: ruleEnumDeclaration : ( ( rule__EnumDeclaration__Group__0 ) ) ;
    public final void ruleEnumDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1557:2: ( ( ( rule__EnumDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1558:2: ( ( rule__EnumDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1558:2: ( ( rule__EnumDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:1559:3: ( rule__EnumDeclaration__Group__0 )
            {
             before(grammarAccess.getEnumDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1560:3: ( rule__EnumDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:1560:4: rule__EnumDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getEnumDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleEnumLiteral"
    // InternalSolverLanguageParser.g:1569:1: entryRuleEnumLiteral : ruleEnumLiteral EOF ;
    public final void entryRuleEnumLiteral() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1570:1: ( ruleEnumLiteral EOF )
            // InternalSolverLanguageParser.g:1571:1: ruleEnumLiteral EOF
            {
             before(grammarAccess.getEnumLiteralRule()); 
            pushFollow(FOLLOW_1);
            ruleEnumLiteral();

            state._fsp--;

             after(grammarAccess.getEnumLiteralRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleEnumLiteral"
    // InternalSolverLanguageParser.g:1578:1: ruleEnumLiteral : ( ( rule__EnumLiteral__NameAssignment ) ) ;
    public final void ruleEnumLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1582:2: ( ( ( rule__EnumLiteral__NameAssignment ) ) )
            // InternalSolverLanguageParser.g:1583:2: ( ( rule__EnumLiteral__NameAssignment ) )
            {
            // InternalSolverLanguageParser.g:1583:2: ( ( rule__EnumLiteral__NameAssignment ) )
            // InternalSolverLanguageParser.g:1584:3: ( rule__EnumLiteral__NameAssignment )
            {
             before(grammarAccess.getEnumLiteralAccess().getNameAssignment()); 
            // InternalSolverLanguageParser.g:1585:3: ( rule__EnumLiteral__NameAssignment )
            // InternalSolverLanguageParser.g:1585:4: rule__EnumLiteral__NameAssignment
            {
            pushFollow(FOLLOW_2);
            rule__EnumLiteral__NameAssignment();

            state._fsp--;


            }

             after(grammarAccess.getEnumLiteralAccess().getNameAssignment()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleScopeDeclaration"
    // InternalSolverLanguageParser.g:1594:1: entryRuleScopeDeclaration : ruleScopeDeclaration EOF ;
    public final void entryRuleScopeDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1595:1: ( ruleScopeDeclaration EOF )
            // InternalSolverLanguageParser.g:1596:1: ruleScopeDeclaration EOF
            {
             before(grammarAccess.getScopeDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleScopeDeclaration();

            state._fsp--;

             after(grammarAccess.getScopeDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleScopeDeclaration"
    // InternalSolverLanguageParser.g:1603:1: ruleScopeDeclaration : ( ( rule__ScopeDeclaration__Alternatives ) ) ;
    public final void ruleScopeDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1607:2: ( ( ( rule__ScopeDeclaration__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1608:2: ( ( rule__ScopeDeclaration__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1608:2: ( ( rule__ScopeDeclaration__Alternatives ) )
            // InternalSolverLanguageParser.g:1609:3: ( rule__ScopeDeclaration__Alternatives )
            {
             before(grammarAccess.getScopeDeclarationAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1610:3: ( rule__ScopeDeclaration__Alternatives )
            // InternalSolverLanguageParser.g:1610:4: rule__ScopeDeclaration__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ScopeDeclaration__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getScopeDeclarationAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExactScope"
    // InternalSolverLanguageParser.g:1619:1: entryRuleExactScope : ruleExactScope EOF ;
    public final void entryRuleExactScope() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1620:1: ( ruleExactScope EOF )
            // InternalSolverLanguageParser.g:1621:1: ruleExactScope EOF
            {
             before(grammarAccess.getExactScopeRule()); 
            pushFollow(FOLLOW_1);
            ruleExactScope();

            state._fsp--;

             after(grammarAccess.getExactScopeRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleExactScope"
    // InternalSolverLanguageParser.g:1628:1: ruleExactScope : ( ( rule__ExactScope__Group__0 ) ) ;
    public final void ruleExactScope() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1632:2: ( ( ( rule__ExactScope__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1633:2: ( ( rule__ExactScope__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1633:2: ( ( rule__ExactScope__Group__0 ) )
            // InternalSolverLanguageParser.g:1634:3: ( rule__ExactScope__Group__0 )
            {
             before(grammarAccess.getExactScopeAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1635:3: ( rule__ExactScope__Group__0 )
            // InternalSolverLanguageParser.g:1635:4: rule__ExactScope__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ExactScope__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getExactScopeAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleBoundedScope"
    // InternalSolverLanguageParser.g:1644:1: entryRuleBoundedScope : ruleBoundedScope EOF ;
    public final void entryRuleBoundedScope() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1645:1: ( ruleBoundedScope EOF )
            // InternalSolverLanguageParser.g:1646:1: ruleBoundedScope EOF
            {
             before(grammarAccess.getBoundedScopeRule()); 
            pushFollow(FOLLOW_1);
            ruleBoundedScope();

            state._fsp--;

             after(grammarAccess.getBoundedScopeRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleBoundedScope"
    // InternalSolverLanguageParser.g:1653:1: ruleBoundedScope : ( ( rule__BoundedScope__Group__0 ) ) ;
    public final void ruleBoundedScope() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1657:2: ( ( ( rule__BoundedScope__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1658:2: ( ( rule__BoundedScope__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1658:2: ( ( rule__BoundedScope__Group__0 ) )
            // InternalSolverLanguageParser.g:1659:3: ( rule__BoundedScope__Group__0 )
            {
             before(grammarAccess.getBoundedScopeAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1660:3: ( rule__BoundedScope__Group__0 )
            // InternalSolverLanguageParser.g:1660:4: rule__BoundedScope__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLowerBoundedScope"
    // InternalSolverLanguageParser.g:1669:1: entryRuleLowerBoundedScope : ruleLowerBoundedScope EOF ;
    public final void entryRuleLowerBoundedScope() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1670:1: ( ruleLowerBoundedScope EOF )
            // InternalSolverLanguageParser.g:1671:1: ruleLowerBoundedScope EOF
            {
             before(grammarAccess.getLowerBoundedScopeRule()); 
            pushFollow(FOLLOW_1);
            ruleLowerBoundedScope();

            state._fsp--;

             after(grammarAccess.getLowerBoundedScopeRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleLowerBoundedScope"
    // InternalSolverLanguageParser.g:1678:1: ruleLowerBoundedScope : ( ( rule__LowerBoundedScope__Group__0 ) ) ;
    public final void ruleLowerBoundedScope() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1682:2: ( ( ( rule__LowerBoundedScope__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1683:2: ( ( rule__LowerBoundedScope__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1683:2: ( ( rule__LowerBoundedScope__Group__0 ) )
            // InternalSolverLanguageParser.g:1684:3: ( rule__LowerBoundedScope__Group__0 )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1685:3: ( rule__LowerBoundedScope__Group__0 )
            // InternalSolverLanguageParser.g:1685:4: rule__LowerBoundedScope__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getLowerBoundedScopeAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleObjectiveDeclaration"
    // InternalSolverLanguageParser.g:1694:1: entryRuleObjectiveDeclaration : ruleObjectiveDeclaration EOF ;
    public final void entryRuleObjectiveDeclaration() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1695:1: ( ruleObjectiveDeclaration EOF )
            // InternalSolverLanguageParser.g:1696:1: ruleObjectiveDeclaration EOF
            {
             before(grammarAccess.getObjectiveDeclarationRule()); 
            pushFollow(FOLLOW_1);
            ruleObjectiveDeclaration();

            state._fsp--;

             after(grammarAccess.getObjectiveDeclarationRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleObjectiveDeclaration"
    // InternalSolverLanguageParser.g:1703:1: ruleObjectiveDeclaration : ( ( rule__ObjectiveDeclaration__Group__0 ) ) ;
    public final void ruleObjectiveDeclaration() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1707:2: ( ( ( rule__ObjectiveDeclaration__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1708:2: ( ( rule__ObjectiveDeclaration__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1708:2: ( ( rule__ObjectiveDeclaration__Group__0 ) )
            // InternalSolverLanguageParser.g:1709:3: ( rule__ObjectiveDeclaration__Group__0 )
            {
             before(grammarAccess.getObjectiveDeclarationAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1710:3: ( rule__ObjectiveDeclaration__Group__0 )
            // InternalSolverLanguageParser.g:1710:4: rule__ObjectiveDeclaration__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ObjectiveDeclaration__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getObjectiveDeclarationAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleUpperMultiplicty"
    // InternalSolverLanguageParser.g:1719:1: entryRuleUpperMultiplicty : ruleUpperMultiplicty EOF ;
    public final void entryRuleUpperMultiplicty() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1720:1: ( ruleUpperMultiplicty EOF )
            // InternalSolverLanguageParser.g:1721:1: ruleUpperMultiplicty EOF
            {
             before(grammarAccess.getUpperMultiplictyRule()); 
            pushFollow(FOLLOW_1);
            ruleUpperMultiplicty();

            state._fsp--;

             after(grammarAccess.getUpperMultiplictyRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleUpperMultiplicty"
    // InternalSolverLanguageParser.g:1728:1: ruleUpperMultiplicty : ( ( rule__UpperMultiplicty__Alternatives ) ) ;
    public final void ruleUpperMultiplicty() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1732:2: ( ( ( rule__UpperMultiplicty__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1733:2: ( ( rule__UpperMultiplicty__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1733:2: ( ( rule__UpperMultiplicty__Alternatives ) )
            // InternalSolverLanguageParser.g:1734:3: ( rule__UpperMultiplicty__Alternatives )
            {
             before(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1735:3: ( rule__UpperMultiplicty__Alternatives )
            // InternalSolverLanguageParser.g:1735:4: rule__UpperMultiplicty__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__UpperMultiplicty__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleReal"
    // InternalSolverLanguageParser.g:1744:1: entryRuleReal : ruleReal EOF ;
    public final void entryRuleReal() throws RecognitionException {
         
        	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();

        try {
            // InternalSolverLanguageParser.g:1748:1: ( ruleReal EOF )
            // InternalSolverLanguageParser.g:1749:1: ruleReal EOF
            {
             before(grammarAccess.getRealRule()); 
            pushFollow(FOLLOW_1);
            ruleReal();

            state._fsp--;

             after(grammarAccess.getRealRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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

            	myHiddenTokenState.restore();

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


    // $ANTLR start "ruleReal"
    // InternalSolverLanguageParser.g:1759:1: ruleReal : ( ( rule__Real__Group__0 ) ) ;
    public final void ruleReal() throws RecognitionException {

        		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1764:2: ( ( ( rule__Real__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1765:2: ( ( rule__Real__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1765:2: ( ( rule__Real__Group__0 ) )
            // InternalSolverLanguageParser.g:1766:3: ( rule__Real__Group__0 )
            {
             before(grammarAccess.getRealAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1767:3: ( rule__Real__Group__0 )
            // InternalSolverLanguageParser.g:1767:4: rule__Real__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Real__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getRealAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);
            	myHiddenTokenState.restore();

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


    // $ANTLR start "entryRuleQualifiedNameSegment"
    // InternalSolverLanguageParser.g:1777:1: entryRuleQualifiedNameSegment : ruleQualifiedNameSegment EOF ;
    public final void entryRuleQualifiedNameSegment() throws RecognitionException {
        try {
            // InternalSolverLanguageParser.g:1778:1: ( ruleQualifiedNameSegment EOF )
            // InternalSolverLanguageParser.g:1779:1: ruleQualifiedNameSegment EOF
            {
             before(grammarAccess.getQualifiedNameSegmentRule()); 
            pushFollow(FOLLOW_1);
            ruleQualifiedNameSegment();

            state._fsp--;

             after(grammarAccess.getQualifiedNameSegmentRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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


    // $ANTLR start "ruleQualifiedNameSegment"
    // InternalSolverLanguageParser.g:1786:1: ruleQualifiedNameSegment : ( ( rule__QualifiedNameSegment__Alternatives ) ) ;
    public final void ruleQualifiedNameSegment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1790:2: ( ( ( rule__QualifiedNameSegment__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1791:2: ( ( rule__QualifiedNameSegment__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1791:2: ( ( rule__QualifiedNameSegment__Alternatives ) )
            // InternalSolverLanguageParser.g:1792:3: ( rule__QualifiedNameSegment__Alternatives )
            {
             before(grammarAccess.getQualifiedNameSegmentAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1793:3: ( rule__QualifiedNameSegment__Alternatives )
            // InternalSolverLanguageParser.g:1793:4: rule__QualifiedNameSegment__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedNameSegment__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getQualifiedNameSegmentAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleQualifiedName"
    // InternalSolverLanguageParser.g:1802:1: entryRuleQualifiedName : ruleQualifiedName EOF ;
    public final void entryRuleQualifiedName() throws RecognitionException {
         
        	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();

        try {
            // InternalSolverLanguageParser.g:1806:1: ( ruleQualifiedName EOF )
            // InternalSolverLanguageParser.g:1807:1: ruleQualifiedName EOF
            {
             before(grammarAccess.getQualifiedNameRule()); 
            pushFollow(FOLLOW_1);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getQualifiedNameRule()); 
            match(input,EOF,FOLLOW_2); 

            }

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

            	myHiddenTokenState.restore();

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


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

        		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1822:2: ( ( ( rule__QualifiedName__Group__0 ) ) )
            // InternalSolverLanguageParser.g:1823:2: ( ( rule__QualifiedName__Group__0 ) )
            {
            // InternalSolverLanguageParser.g:1823:2: ( ( rule__QualifiedName__Group__0 ) )
            // InternalSolverLanguageParser.g:1824:3: ( rule__QualifiedName__Group__0 )
            {
             before(grammarAccess.getQualifiedNameAccess().getGroup()); 
            // InternalSolverLanguageParser.g:1825:3: ( rule__QualifiedName__Group__0 )
            // InternalSolverLanguageParser.g:1825:4: rule__QualifiedName__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getQualifiedNameAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);
            	myHiddenTokenState.restore();

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


    // $ANTLR start "ruleAttributeKind"
    // InternalSolverLanguageParser.g:1835:1: ruleAttributeKind : ( ( rule__AttributeKind__Alternatives ) ) ;
    public final void ruleAttributeKind() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1839:1: ( ( ( rule__AttributeKind__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1840:2: ( ( rule__AttributeKind__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1840:2: ( ( rule__AttributeKind__Alternatives ) )
            // InternalSolverLanguageParser.g:1841:3: ( rule__AttributeKind__Alternatives )
            {
             before(grammarAccess.getAttributeKindAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1842:3: ( rule__AttributeKind__Alternatives )
            // InternalSolverLanguageParser.g:1842:4: rule__AttributeKind__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__AttributeKind__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getAttributeKindAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleComparisonOperator"
    // InternalSolverLanguageParser.g:1851:1: ruleComparisonOperator : ( ( rule__ComparisonOperator__Alternatives ) ) ;
    public final void ruleComparisonOperator() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1855:1: ( ( ( rule__ComparisonOperator__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1856:2: ( ( rule__ComparisonOperator__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1856:2: ( ( rule__ComparisonOperator__Alternatives ) )
            // InternalSolverLanguageParser.g:1857:3: ( rule__ComparisonOperator__Alternatives )
            {
             before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1858:3: ( rule__ComparisonOperator__Alternatives )
            // InternalSolverLanguageParser.g:1858:4: rule__ComparisonOperator__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ComparisonOperator__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleAdditiveBinaryOperator"
    // InternalSolverLanguageParser.g:1867:1: ruleAdditiveBinaryOperator : ( ( rule__AdditiveBinaryOperator__Alternatives ) ) ;
    public final void ruleAdditiveBinaryOperator() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1871:1: ( ( ( rule__AdditiveBinaryOperator__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1872:2: ( ( rule__AdditiveBinaryOperator__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1872:2: ( ( rule__AdditiveBinaryOperator__Alternatives ) )
            // InternalSolverLanguageParser.g:1873:3: ( rule__AdditiveBinaryOperator__Alternatives )
            {
             before(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1874:3: ( rule__AdditiveBinaryOperator__Alternatives )
            // InternalSolverLanguageParser.g:1874:4: rule__AdditiveBinaryOperator__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__AdditiveBinaryOperator__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleMultiplicativeBinaryOperator"
    // InternalSolverLanguageParser.g:1883:1: ruleMultiplicativeBinaryOperator : ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) ;
    public final void ruleMultiplicativeBinaryOperator() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1887:1: ( ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1888:2: ( ( rule__MultiplicativeBinaryOperator__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1888:2: ( ( rule__MultiplicativeBinaryOperator__Alternatives ) )
            // InternalSolverLanguageParser.g:1889:3: ( rule__MultiplicativeBinaryOperator__Alternatives )
            {
             before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1890:3: ( rule__MultiplicativeBinaryOperator__Alternatives )
            // InternalSolverLanguageParser.g:1890:4: rule__MultiplicativeBinaryOperator__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicativeBinaryOperator__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleExponentialOp"
    // InternalSolverLanguageParser.g:1899:1: ruleExponentialOp : ( ( CircumflexAccent ) ) ;
    public final void ruleExponentialOp() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1903:1: ( ( ( CircumflexAccent ) ) )
            // InternalSolverLanguageParser.g:1904:2: ( ( CircumflexAccent ) )
            {
            // InternalSolverLanguageParser.g:1904:2: ( ( CircumflexAccent ) )
            // InternalSolverLanguageParser.g:1905:3: ( CircumflexAccent )
            {
             before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); 
            // InternalSolverLanguageParser.g:1906:3: ( CircumflexAccent )
            // InternalSolverLanguageParser.g:1906:4: CircumflexAccent
            {
            match(input,CircumflexAccent,FOLLOW_2); 

            }

             after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleUnaryOperator"
    // InternalSolverLanguageParser.g:1915:1: ruleUnaryOperator : ( ( rule__UnaryOperator__Alternatives ) ) ;
    public final void ruleUnaryOperator() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1919:1: ( ( ( rule__UnaryOperator__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1920:2: ( ( rule__UnaryOperator__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1920:2: ( ( rule__UnaryOperator__Alternatives ) )
            // InternalSolverLanguageParser.g:1921:3: ( rule__UnaryOperator__Alternatives )
            {
             before(grammarAccess.getUnaryOperatorAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1922:3: ( rule__UnaryOperator__Alternatives )
            // InternalSolverLanguageParser.g:1922:4: rule__UnaryOperator__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__UnaryOperator__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getUnaryOperatorAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleLogicValue"
    // InternalSolverLanguageParser.g:1931:1: ruleLogicValue : ( ( rule__LogicValue__Alternatives ) ) ;
    public final void ruleLogicValue() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1935:1: ( ( ( rule__LogicValue__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1936:2: ( ( rule__LogicValue__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1936:2: ( ( rule__LogicValue__Alternatives ) )
            // InternalSolverLanguageParser.g:1937:3: ( rule__LogicValue__Alternatives )
            {
             before(grammarAccess.getLogicValueAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1938:3: ( rule__LogicValue__Alternatives )
            // InternalSolverLanguageParser.g:1938:4: rule__LogicValue__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__LogicValue__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getLogicValueAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleObjectiveKind"
    // InternalSolverLanguageParser.g:1947:1: ruleObjectiveKind : ( ( rule__ObjectiveKind__Alternatives ) ) ;
    public final void ruleObjectiveKind() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1951:1: ( ( ( rule__ObjectiveKind__Alternatives ) ) )
            // InternalSolverLanguageParser.g:1952:2: ( ( rule__ObjectiveKind__Alternatives ) )
            {
            // InternalSolverLanguageParser.g:1952:2: ( ( rule__ObjectiveKind__Alternatives ) )
            // InternalSolverLanguageParser.g:1953:3: ( rule__ObjectiveKind__Alternatives )
            {
             before(grammarAccess.getObjectiveKindAccess().getAlternatives()); 
            // InternalSolverLanguageParser.g:1954:3: ( rule__ObjectiveKind__Alternatives )
            // InternalSolverLanguageParser.g:1954:4: rule__ObjectiveKind__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__ObjectiveKind__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getObjectiveKindAccess().getAlternatives()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Statement__Alternatives"
    // InternalSolverLanguageParser.g:1962:1: rule__Statement__Alternatives : ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPredicateDefintion ) | ( ruleDefaultAssertion ) | ( ruleFunctionDefinition ) | ( ruleAttribute ) | ( ruleExternDeclaration ) | ( ruleScopeDeclaration ) | ( ruleObjectiveDeclaration ) | ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) );
    public final void rule__Statement__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:1966:1: ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPredicateDefintion ) | ( ruleDefaultAssertion ) | ( ruleFunctionDefinition ) | ( ruleAttribute ) | ( ruleExternDeclaration ) | ( ruleScopeDeclaration ) | ( ruleObjectiveDeclaration ) | ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) )
            int alt1=11;
            alt1 = dfa1.predict(input);
            switch (alt1) {
                case 1 :
                    // InternalSolverLanguageParser.g:1967:2: ( ruleAssertionOrDefinition )
                    {
                    // InternalSolverLanguageParser.g:1967:2: ( ruleAssertionOrDefinition )
                    // InternalSolverLanguageParser.g:1968:3: ruleAssertionOrDefinition
                    {
                     before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleAssertionOrDefinition();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:1973:2: ( rulePredicateDefinition )
                    {
                    // InternalSolverLanguageParser.g:1973:2: ( rulePredicateDefinition )
                    // InternalSolverLanguageParser.g:1974:3: rulePredicateDefinition
                    {
                     before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    rulePredicateDefinition();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:1979:2: ( ruleUnnamedErrorPredicateDefintion )
                    {
                    // InternalSolverLanguageParser.g:1979:2: ( ruleUnnamedErrorPredicateDefintion )
                    // InternalSolverLanguageParser.g:1980:3: ruleUnnamedErrorPredicateDefintion
                    {
                     before(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleUnnamedErrorPredicateDefintion();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:1985:2: ( ruleDefaultAssertion )
                    {
                    // InternalSolverLanguageParser.g:1985:2: ( ruleDefaultAssertion )
                    // InternalSolverLanguageParser.g:1986:3: ruleDefaultAssertion
                    {
                     before(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); 
                    pushFollow(FOLLOW_2);
                    ruleDefaultAssertion();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); 

                    }


                    }
                    break;
                case 5 :
                    // InternalSolverLanguageParser.g:1991:2: ( ruleFunctionDefinition )
                    {
                    // InternalSolverLanguageParser.g:1991:2: ( ruleFunctionDefinition )
                    // InternalSolverLanguageParser.g:1992:3: ruleFunctionDefinition
                    {
                     before(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); 
                    pushFollow(FOLLOW_2);
                    ruleFunctionDefinition();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); 

                    }


                    }
                    break;
                case 6 :
                    // InternalSolverLanguageParser.g:1997:2: ( ruleAttribute )
                    {
                    // InternalSolverLanguageParser.g:1997:2: ( ruleAttribute )
                    // InternalSolverLanguageParser.g:1998:3: ruleAttribute
                    {
                     before(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); 
                    pushFollow(FOLLOW_2);
                    ruleAttribute();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); 

                    }


                    }
                    break;
                case 7 :
                    // InternalSolverLanguageParser.g:2003:2: ( ruleExternDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2003:2: ( ruleExternDeclaration )
                    // InternalSolverLanguageParser.g:2004:3: ruleExternDeclaration
                    {
                     before(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); 
                    pushFollow(FOLLOW_2);
                    ruleExternDeclaration();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); 

                    }


                    }
                    break;
                case 8 :
                    // InternalSolverLanguageParser.g:2009:2: ( ruleScopeDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2009:2: ( ruleScopeDeclaration )
                    // InternalSolverLanguageParser.g:2010:3: ruleScopeDeclaration
                    {
                     before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); 
                    pushFollow(FOLLOW_2);
                    ruleScopeDeclaration();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); 

                    }


                    }
                    break;
                case 9 :
                    // InternalSolverLanguageParser.g:2015:2: ( ruleObjectiveDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2015:2: ( ruleObjectiveDeclaration )
                    // InternalSolverLanguageParser.g:2016:3: ruleObjectiveDeclaration
                    {
                     before(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); 
                    pushFollow(FOLLOW_2);
                    ruleObjectiveDeclaration();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); 

                    }


                    }
                    break;
                case 10 :
                    // InternalSolverLanguageParser.g:2021:2: ( ruleClassDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2021:2: ( ruleClassDeclaration )
                    // InternalSolverLanguageParser.g:2022:3: ruleClassDeclaration
                    {
                     before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); 
                    pushFollow(FOLLOW_2);
                    ruleClassDeclaration();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); 

                    }


                    }
                    break;
                case 11 :
                    // InternalSolverLanguageParser.g:2027:2: ( ruleEnumDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2027:2: ( ruleEnumDeclaration )
                    // InternalSolverLanguageParser.g:2028:3: ruleEnumDeclaration
                    {
                     before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); 
                    pushFollow(FOLLOW_2);
                    ruleEnumDeclaration();

                    state._fsp--;

                     after(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Import__Alternatives"
    // InternalSolverLanguageParser.g:2037:1: rule__Import__Alternatives : ( ( ruleUriImport ) | ( ruleNamespaceImport ) );
    public final void rule__Import__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2041:1: ( ( ruleUriImport ) | ( ruleNamespaceImport ) )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==Import) ) {
                int LA2_1 = input.LA(2);

                if ( (LA2_1==Object||LA2_1==RULE_QUOTED_ID||LA2_1==RULE_ID) ) {
                    alt2=2;
                }
                else if ( (LA2_1==RULE_STRING) ) {
                    alt2=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // InternalSolverLanguageParser.g:2042:2: ( ruleUriImport )
                    {
                    // InternalSolverLanguageParser.g:2042:2: ( ruleUriImport )
                    // InternalSolverLanguageParser.g:2043:3: ruleUriImport
                    {
                     before(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleUriImport();

                    state._fsp--;

                     after(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2048:2: ( ruleNamespaceImport )
                    {
                    // InternalSolverLanguageParser.g:2048:2: ( ruleNamespaceImport )
                    // InternalSolverLanguageParser.g:2049:3: ruleNamespaceImport
                    {
                     before(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleNamespaceImport();

                    state._fsp--;

                     after(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Alternatives_1"
    // InternalSolverLanguageParser.g:2058:1: rule__AssertionOrDefinition__Alternatives_1 : ( ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) );
    public final void rule__AssertionOrDefinition__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2062:1: ( ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) )
            int alt3=3;
            switch ( input.LA(1) ) {
            case Colon:
            case RULE_FULL_STOP:
                {
                alt3=1;
                }
                break;
            case ColonHyphenMinus:
                {
                alt3=2;
                }
                break;
            case ColonEqualsSign:
                {
                alt3=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }

            switch (alt3) {
                case 1 :
                    // InternalSolverLanguageParser.g:2063:2: ( ( rule__AssertionOrDefinition__Group_1_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2063:2: ( ( rule__AssertionOrDefinition__Group_1_0__0 ) )
                    // InternalSolverLanguageParser.g:2064:3: ( rule__AssertionOrDefinition__Group_1_0__0 )
                    {
                     before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); 
                    // InternalSolverLanguageParser.g:2065:3: ( rule__AssertionOrDefinition__Group_1_0__0 )
                    // InternalSolverLanguageParser.g:2065:4: rule__AssertionOrDefinition__Group_1_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__AssertionOrDefinition__Group_1_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2069:2: ( ( rule__AssertionOrDefinition__Group_1_1__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2069:2: ( ( rule__AssertionOrDefinition__Group_1_1__0 ) )
                    // InternalSolverLanguageParser.g:2070:3: ( rule__AssertionOrDefinition__Group_1_1__0 )
                    {
                     before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); 
                    // InternalSolverLanguageParser.g:2071:3: ( rule__AssertionOrDefinition__Group_1_1__0 )
                    // InternalSolverLanguageParser.g:2071:4: rule__AssertionOrDefinition__Group_1_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__AssertionOrDefinition__Group_1_1__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2075:2: ( ( rule__AssertionOrDefinition__Group_1_2__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2075:2: ( ( rule__AssertionOrDefinition__Group_1_2__0 ) )
                    // InternalSolverLanguageParser.g:2076:3: ( rule__AssertionOrDefinition__Group_1_2__0 )
                    {
                     before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); 
                    // InternalSolverLanguageParser.g:2077:3: ( rule__AssertionOrDefinition__Group_1_2__0 )
                    // InternalSolverLanguageParser.g:2077:4: rule__AssertionOrDefinition__Group_1_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__AssertionOrDefinition__Group_1_2__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Alternatives_0"
    // InternalSolverLanguageParser.g:2085:1: rule__PredicateDefinition__Alternatives_0 : ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( ( rule__PredicateDefinition__Group_0_1__0 ) ) );
    public final void rule__PredicateDefinition__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2089:1: ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( ( rule__PredicateDefinition__Group_0_1__0 ) ) )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==Functional) ) {
                alt4=1;
            }
            else if ( (LA4_0==Error) ) {
                alt4=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // InternalSolverLanguageParser.g:2090:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2090:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) )
                    // InternalSolverLanguageParser.g:2091:3: ( rule__PredicateDefinition__Group_0_0__0 )
                    {
                     before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); 
                    // InternalSolverLanguageParser.g:2092:3: ( rule__PredicateDefinition__Group_0_0__0 )
                    // InternalSolverLanguageParser.g:2092:4: rule__PredicateDefinition__Group_0_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PredicateDefinition__Group_0_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2096:2: ( ( rule__PredicateDefinition__Group_0_1__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2096:2: ( ( rule__PredicateDefinition__Group_0_1__0 ) )
                    // InternalSolverLanguageParser.g:2097:3: ( rule__PredicateDefinition__Group_0_1__0 )
                    {
                     before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); 
                    // InternalSolverLanguageParser.g:2098:3: ( rule__PredicateDefinition__Group_0_1__0 )
                    // InternalSolverLanguageParser.g:2098:4: rule__PredicateDefinition__Group_0_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PredicateDefinition__Group_0_1__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDeclaration__Alternatives"
    // InternalSolverLanguageParser.g:2106:1: rule__ExternDeclaration__Alternatives : ( ( ruleExternPredicateDeclaration ) | ( ruleExternFunctionDeclaration ) | ( ruleExternAggregationOperatorDeclaration ) | ( ruleExternDatatypeDeclaration ) );
    public final void rule__ExternDeclaration__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2110:1: ( ( ruleExternPredicateDeclaration ) | ( ruleExternFunctionDeclaration ) | ( ruleExternAggregationOperatorDeclaration ) | ( ruleExternDatatypeDeclaration ) )
            int alt5=4;
            alt5 = dfa5.predict(input);
            switch (alt5) {
                case 1 :
                    // InternalSolverLanguageParser.g:2111:2: ( ruleExternPredicateDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2111:2: ( ruleExternPredicateDeclaration )
                    // InternalSolverLanguageParser.g:2112:3: ruleExternPredicateDeclaration
                    {
                     before(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleExternPredicateDeclaration();

                    state._fsp--;

                     after(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2117:2: ( ruleExternFunctionDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2117:2: ( ruleExternFunctionDeclaration )
                    // InternalSolverLanguageParser.g:2118:3: ruleExternFunctionDeclaration
                    {
                     before(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleExternFunctionDeclaration();

                    state._fsp--;

                     after(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2123:2: ( ruleExternAggregationOperatorDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2123:2: ( ruleExternAggregationOperatorDeclaration )
                    // InternalSolverLanguageParser.g:2124:3: ruleExternAggregationOperatorDeclaration
                    {
                     before(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleExternAggregationOperatorDeclaration();

                    state._fsp--;

                     after(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2129:2: ( ruleExternDatatypeDeclaration )
                    {
                    // InternalSolverLanguageParser.g:2129:2: ( ruleExternDatatypeDeclaration )
                    // InternalSolverLanguageParser.g:2130:3: ruleExternDatatypeDeclaration
                    {
                     before(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); 
                    pushFollow(FOLLOW_2);
                    ruleExternDatatypeDeclaration();

                    state._fsp--;

                     after(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Alternatives"
    // InternalSolverLanguageParser.g:2139:1: rule__Expression__Alternatives : ( ( ruleConditionalExpression ) | ( ruleLetExpression ) | ( ( rule__Expression__Group_2__0 ) ) );
    public final void rule__Expression__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2143:1: ( ( ruleConditionalExpression ) | ( ruleLetExpression ) | ( ( rule__Expression__Group_2__0 ) ) )
            int alt6=3;
            switch ( input.LA(1) ) {
            case If:
                {
                alt6=1;
                }
                break;
            case Let:
                {
                alt6=2;
                }
                break;
            case Unknown:
            case Object:
            case Count:
            case Empty:
            case Error:
            case False:
            case True:
            case Inf:
            case ExclamationMark:
            case LeftParenthesis:
            case PlusSign:
            case HyphenMinus:
            case QuestionMark:
            case LeftSquareBracket:
            case Tilde:
            case RULE_STRING:
            case RULE_QUOTED_ID:
            case RULE_ID:
            case RULE_INT:
                {
                alt6=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }

            switch (alt6) {
                case 1 :
                    // InternalSolverLanguageParser.g:2144:2: ( ruleConditionalExpression )
                    {
                    // InternalSolverLanguageParser.g:2144:2: ( ruleConditionalExpression )
                    // InternalSolverLanguageParser.g:2145:3: ruleConditionalExpression
                    {
                     before(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleConditionalExpression();

                    state._fsp--;

                     after(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2150:2: ( ruleLetExpression )
                    {
                    // InternalSolverLanguageParser.g:2150:2: ( ruleLetExpression )
                    // InternalSolverLanguageParser.g:2151:3: ruleLetExpression
                    {
                     before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleLetExpression();

                    state._fsp--;

                     after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2156:2: ( ( rule__Expression__Group_2__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2156:2: ( ( rule__Expression__Group_2__0 ) )
                    // InternalSolverLanguageParser.g:2157:3: ( rule__Expression__Group_2__0 )
                    {
                     before(grammarAccess.getExpressionAccess().getGroup_2()); 
                    // InternalSolverLanguageParser.g:2158:3: ( rule__Expression__Group_2__0 )
                    // InternalSolverLanguageParser.g:2158:4: rule__Expression__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__Expression__Group_2__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getExpressionAccess().getGroup_2()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Alternatives_1"
    // InternalSolverLanguageParser.g:2166:1: rule__DisjunctiveExpression__Alternatives_1 : ( ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) );
    public final void rule__DisjunctiveExpression__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2170:1: ( ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) )
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==Semicolon) ) {
                alt7=1;
            }
            else if ( (LA7_0==HyphenMinusGreaterThanSign) ) {
                alt7=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }
            switch (alt7) {
                case 1 :
                    // InternalSolverLanguageParser.g:2171:2: ( ( rule__DisjunctiveExpression__Group_1_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2171:2: ( ( rule__DisjunctiveExpression__Group_1_0__0 ) )
                    // InternalSolverLanguageParser.g:2172:3: ( rule__DisjunctiveExpression__Group_1_0__0 )
                    {
                     before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); 
                    // InternalSolverLanguageParser.g:2173:3: ( rule__DisjunctiveExpression__Group_1_0__0 )
                    // InternalSolverLanguageParser.g:2173:4: rule__DisjunctiveExpression__Group_1_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__DisjunctiveExpression__Group_1_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2177:2: ( ( rule__DisjunctiveExpression__Group_1_1__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2177:2: ( ( rule__DisjunctiveExpression__Group_1_1__0 ) )
                    // InternalSolverLanguageParser.g:2178:3: ( rule__DisjunctiveExpression__Group_1_1__0 )
                    {
                     before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); 
                    // InternalSolverLanguageParser.g:2179:3: ( rule__DisjunctiveExpression__Group_1_1__0 )
                    // InternalSolverLanguageParser.g:2179:4: rule__DisjunctiveExpression__Group_1_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__DisjunctiveExpression__Group_1_1__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnaryExpression__Alternatives"
    // InternalSolverLanguageParser.g:2187:1: rule__UnaryExpression__Alternatives : ( ( ruleBracedAggregateExpression ) | ( ( rule__UnaryExpression__Group_1__0 ) ) );
    public final void rule__UnaryExpression__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2191:1: ( ( ruleBracedAggregateExpression ) | ( ( rule__UnaryExpression__Group_1__0 ) ) )
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==Unknown||LA8_0==Object||(LA8_0>=Count && LA8_0<=False)||LA8_0==True||LA8_0==Inf||LA8_0==LeftParenthesis||LA8_0==LeftSquareBracket||(LA8_0>=Tilde && LA8_0<=RULE_QUOTED_ID)||(LA8_0>=RULE_ID && LA8_0<=RULE_INT)) ) {
                alt8=1;
            }
            else if ( (LA8_0==ExclamationMark||LA8_0==PlusSign||LA8_0==HyphenMinus||LA8_0==QuestionMark) ) {
                alt8=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }
            switch (alt8) {
                case 1 :
                    // InternalSolverLanguageParser.g:2192:2: ( ruleBracedAggregateExpression )
                    {
                    // InternalSolverLanguageParser.g:2192:2: ( ruleBracedAggregateExpression )
                    // InternalSolverLanguageParser.g:2193:3: ruleBracedAggregateExpression
                    {
                     before(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleBracedAggregateExpression();

                    state._fsp--;

                     after(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2198:2: ( ( rule__UnaryExpression__Group_1__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2198:2: ( ( rule__UnaryExpression__Group_1__0 ) )
                    // InternalSolverLanguageParser.g:2199:3: ( rule__UnaryExpression__Group_1__0 )
                    {
                     before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); 
                    // InternalSolverLanguageParser.g:2200:3: ( rule__UnaryExpression__Group_1__0 )
                    // InternalSolverLanguageParser.g:2200:4: rule__UnaryExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__UnaryExpression__Group_1__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__BracedAggregateExpression__Alternatives"
    // InternalSolverLanguageParser.g:2208:1: rule__BracedAggregateExpression__Alternatives : ( ( ruleAtomicExpression ) | ( ruleAggregation ) | ( ruleCount ) );
    public final void rule__BracedAggregateExpression__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2212:1: ( ( ruleAtomicExpression ) | ( ruleAggregation ) | ( ruleCount ) )
            int alt9=3;
            alt9 = dfa9.predict(input);
            switch (alt9) {
                case 1 :
                    // InternalSolverLanguageParser.g:2213:2: ( ruleAtomicExpression )
                    {
                    // InternalSolverLanguageParser.g:2213:2: ( ruleAtomicExpression )
                    // InternalSolverLanguageParser.g:2214:3: ruleAtomicExpression
                    {
                     before(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleAtomicExpression();

                    state._fsp--;

                     after(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2219:2: ( ruleAggregation )
                    {
                    // InternalSolverLanguageParser.g:2219:2: ( ruleAggregation )
                    // InternalSolverLanguageParser.g:2220:3: ruleAggregation
                    {
                     before(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleAggregation();

                    state._fsp--;

                     after(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2225:2: ( ruleCount )
                    {
                    // InternalSolverLanguageParser.g:2225:2: ( ruleCount )
                    // InternalSolverLanguageParser.g:2226:3: ruleCount
                    {
                     before(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleCount();

                    state._fsp--;

                     after(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AtomicExpression__Alternatives"
    // InternalSolverLanguageParser.g:2235:1: rule__AtomicExpression__Alternatives : ( ( ruleReference ) | ( ruleCall ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_4__0 ) ) );
    public final void rule__AtomicExpression__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2239:1: ( ( ruleReference ) | ( ruleCall ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_4__0 ) ) )
            int alt10=5;
            alt10 = dfa10.predict(input);
            switch (alt10) {
                case 1 :
                    // InternalSolverLanguageParser.g:2240:2: ( ruleReference )
                    {
                    // InternalSolverLanguageParser.g:2240:2: ( ruleReference )
                    // InternalSolverLanguageParser.g:2241:3: ruleReference
                    {
                     before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleReference();

                    state._fsp--;

                     after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2246:2: ( ruleCall )
                    {
                    // InternalSolverLanguageParser.g:2246:2: ( ruleCall )
                    // InternalSolverLanguageParser.g:2247:3: ruleCall
                    {
                     before(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleCall();

                    state._fsp--;

                     after(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2252:2: ( ruleInterval )
                    {
                    // InternalSolverLanguageParser.g:2252:2: ( ruleInterval )
                    // InternalSolverLanguageParser.g:2253:3: ruleInterval
                    {
                     before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleInterval();

                    state._fsp--;

                     after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2258:2: ( ruleLiteral )
                    {
                    // InternalSolverLanguageParser.g:2258:2: ( ruleLiteral )
                    // InternalSolverLanguageParser.g:2259:3: ruleLiteral
                    {
                     before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); 
                    pushFollow(FOLLOW_2);
                    ruleLiteral();

                    state._fsp--;

                     after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); 

                    }


                    }
                    break;
                case 5 :
                    // InternalSolverLanguageParser.g:2264:2: ( ( rule__AtomicExpression__Group_4__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2264:2: ( ( rule__AtomicExpression__Group_4__0 ) )
                    // InternalSolverLanguageParser.g:2265:3: ( rule__AtomicExpression__Group_4__0 )
                    {
                     before(grammarAccess.getAtomicExpressionAccess().getGroup_4()); 
                    // InternalSolverLanguageParser.g:2266:3: ( rule__AtomicExpression__Group_4__0 )
                    // InternalSolverLanguageParser.g:2266:4: rule__AtomicExpression__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__AtomicExpression__Group_4__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getAtomicExpressionAccess().getGroup_4()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Argument__Alternatives"
    // InternalSolverLanguageParser.g:2274:1: rule__Argument__Alternatives : ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedVariableArgument ) | ( ruleTypedStarArgument ) );
    public final void rule__Argument__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2278:1: ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedVariableArgument ) | ( ruleTypedStarArgument ) )
            int alt11=4;
            alt11 = dfa11.predict(input);
            switch (alt11) {
                case 1 :
                    // InternalSolverLanguageParser.g:2279:2: ( ruleExpressionArgument )
                    {
                    // InternalSolverLanguageParser.g:2279:2: ( ruleExpressionArgument )
                    // InternalSolverLanguageParser.g:2280:3: ruleExpressionArgument
                    {
                     before(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleExpressionArgument();

                    state._fsp--;

                     after(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2285:2: ( ruleStarArgument )
                    {
                    // InternalSolverLanguageParser.g:2285:2: ( ruleStarArgument )
                    // InternalSolverLanguageParser.g:2286:3: ruleStarArgument
                    {
                     before(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleStarArgument();

                    state._fsp--;

                     after(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2291:2: ( ruleTypedVariableArgument )
                    {
                    // InternalSolverLanguageParser.g:2291:2: ( ruleTypedVariableArgument )
                    // InternalSolverLanguageParser.g:2292:3: ruleTypedVariableArgument
                    {
                     before(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleTypedVariableArgument();

                    state._fsp--;

                     after(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2297:2: ( ruleTypedStarArgument )
                    {
                    // InternalSolverLanguageParser.g:2297:2: ( ruleTypedStarArgument )
                    // InternalSolverLanguageParser.g:2298:3: ruleTypedStarArgument
                    {
                     before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); 
                    pushFollow(FOLLOW_2);
                    ruleTypedStarArgument();

                    state._fsp--;

                     after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PathComponent__Alternatives_2"
    // InternalSolverLanguageParser.g:2307:1: rule__PathComponent__Alternatives_2 : ( ( ( rule__PathComponent__TransitiveClosureAssignment_2_0 ) ) | ( ( rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 ) ) );
    public final void rule__PathComponent__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2311:1: ( ( ( rule__PathComponent__TransitiveClosureAssignment_2_0 ) ) | ( ( rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 ) ) )
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==RULE_TRANSITIVE_CLOSURE) ) {
                alt12=1;
            }
            else if ( (LA12_0==RULE_REFLEXIVE_TRANSITIVE_CLOSURE) ) {
                alt12=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // InternalSolverLanguageParser.g:2312:2: ( ( rule__PathComponent__TransitiveClosureAssignment_2_0 ) )
                    {
                    // InternalSolverLanguageParser.g:2312:2: ( ( rule__PathComponent__TransitiveClosureAssignment_2_0 ) )
                    // InternalSolverLanguageParser.g:2313:3: ( rule__PathComponent__TransitiveClosureAssignment_2_0 )
                    {
                     before(grammarAccess.getPathComponentAccess().getTransitiveClosureAssignment_2_0()); 
                    // InternalSolverLanguageParser.g:2314:3: ( rule__PathComponent__TransitiveClosureAssignment_2_0 )
                    // InternalSolverLanguageParser.g:2314:4: rule__PathComponent__TransitiveClosureAssignment_2_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PathComponent__TransitiveClosureAssignment_2_0();

                    state._fsp--;


                    }

                     after(grammarAccess.getPathComponentAccess().getTransitiveClosureAssignment_2_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2318:2: ( ( rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 ) )
                    {
                    // InternalSolverLanguageParser.g:2318:2: ( ( rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 ) )
                    // InternalSolverLanguageParser.g:2319:3: ( rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 )
                    {
                     before(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureAssignment_2_1()); 
                    // InternalSolverLanguageParser.g:2320:3: ( rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 )
                    // InternalSolverLanguageParser.g:2320:4: rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1();

                    state._fsp--;


                    }

                     after(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureAssignment_2_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Literal__Alternatives"
    // InternalSolverLanguageParser.g:2328:1: rule__Literal__Alternatives : ( ( ruleLogicLiteral ) | ( ruleIntLiteral ) | ( ruleRealLiteral ) | ( ruleInfinityLiteral ) | ( ruleEmptyLiteral ) | ( ruleStringLiteral ) );
    public final void rule__Literal__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2332:1: ( ( ruleLogicLiteral ) | ( ruleIntLiteral ) | ( ruleRealLiteral ) | ( ruleInfinityLiteral ) | ( ruleEmptyLiteral ) | ( ruleStringLiteral ) )
            int alt13=6;
            switch ( input.LA(1) ) {
            case Unknown:
            case Error:
            case False:
            case True:
                {
                alt13=1;
                }
                break;
            case RULE_INT:
                {
                int LA13_2 = input.LA(2);

                if ( (LA13_2==FullStop) ) {
                    alt13=3;
                }
                else if ( (LA13_2==EOF||LA13_2==Else||LA13_2==Then||(LA13_2>=ExclamationMarkEqualsSign && LA13_2<=ColonHyphenMinus)||(LA13_2>=ColonEqualsSign && LA13_2<=As)||LA13_2==In||(LA13_2>=RightParenthesis && LA13_2<=HyphenMinus)||(LA13_2>=Solidus && LA13_2<=LessThanSign)||LA13_2==GreaterThanSign||(LA13_2>=RightSquareBracket && LA13_2<=CircumflexAccent)||(LA13_2>=VerticalLine && LA13_2<=RightCurlyBracket)||LA13_2==RULE_FULL_STOP) ) {
                    alt13=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 13, 2, input);

                    throw nvae;
                }
                }
                break;
            case Inf:
                {
                alt13=4;
                }
                break;
            case Empty:
                {
                alt13=5;
                }
                break;
            case RULE_STRING:
                {
                alt13=6;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }

            switch (alt13) {
                case 1 :
                    // InternalSolverLanguageParser.g:2333:2: ( ruleLogicLiteral )
                    {
                    // InternalSolverLanguageParser.g:2333:2: ( ruleLogicLiteral )
                    // InternalSolverLanguageParser.g:2334:3: ruleLogicLiteral
                    {
                     before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleLogicLiteral();

                    state._fsp--;

                     after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2339:2: ( ruleIntLiteral )
                    {
                    // InternalSolverLanguageParser.g:2339:2: ( ruleIntLiteral )
                    // InternalSolverLanguageParser.g:2340:3: ruleIntLiteral
                    {
                     before(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleIntLiteral();

                    state._fsp--;

                     after(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2345:2: ( ruleRealLiteral )
                    {
                    // InternalSolverLanguageParser.g:2345:2: ( ruleRealLiteral )
                    // InternalSolverLanguageParser.g:2346:3: ruleRealLiteral
                    {
                     before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleRealLiteral();

                    state._fsp--;

                     after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2351:2: ( ruleInfinityLiteral )
                    {
                    // InternalSolverLanguageParser.g:2351:2: ( ruleInfinityLiteral )
                    // InternalSolverLanguageParser.g:2352:3: ruleInfinityLiteral
                    {
                     before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); 
                    pushFollow(FOLLOW_2);
                    ruleInfinityLiteral();

                    state._fsp--;

                     after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); 

                    }


                    }
                    break;
                case 5 :
                    // InternalSolverLanguageParser.g:2357:2: ( ruleEmptyLiteral )
                    {
                    // InternalSolverLanguageParser.g:2357:2: ( ruleEmptyLiteral )
                    // InternalSolverLanguageParser.g:2358:3: ruleEmptyLiteral
                    {
                     before(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); 
                    pushFollow(FOLLOW_2);
                    ruleEmptyLiteral();

                    state._fsp--;

                     after(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); 

                    }


                    }
                    break;
                case 6 :
                    // InternalSolverLanguageParser.g:2363:2: ( ruleStringLiteral )
                    {
                    // InternalSolverLanguageParser.g:2363:2: ( ruleStringLiteral )
                    // InternalSolverLanguageParser.g:2364:3: ruleStringLiteral
                    {
                     before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); 
                    pushFollow(FOLLOW_2);
                    ruleStringLiteral();

                    state._fsp--;

                     after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassDeclaration__Alternatives_4"
    // InternalSolverLanguageParser.g:2373:1: rule__ClassDeclaration__Alternatives_4 : ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( RULE_FULL_STOP ) );
    public final void rule__ClassDeclaration__Alternatives_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2377:1: ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( RULE_FULL_STOP ) )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==LeftCurlyBracket) ) {
                alt14=1;
            }
            else if ( (LA14_0==RULE_FULL_STOP) ) {
                alt14=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // InternalSolverLanguageParser.g:2378:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2378:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) )
                    // InternalSolverLanguageParser.g:2379:3: ( rule__ClassDeclaration__Group_4_0__0 )
                    {
                     before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); 
                    // InternalSolverLanguageParser.g:2380:3: ( rule__ClassDeclaration__Group_4_0__0 )
                    // InternalSolverLanguageParser.g:2380:4: rule__ClassDeclaration__Group_4_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassDeclaration__Group_4_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2384:2: ( RULE_FULL_STOP )
                    {
                    // InternalSolverLanguageParser.g:2384:2: ( RULE_FULL_STOP )
                    // InternalSolverLanguageParser.g:2385:3: RULE_FULL_STOP
                    {
                     before(grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); 
                    match(input,RULE_FULL_STOP,FOLLOW_2); 
                     after(grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Field__Alternatives_0"
    // InternalSolverLanguageParser.g:2394:1: rule__Field__Alternatives_0 : ( ( ( rule__Field__ContainmentAssignment_0_0 ) ) | ( ( rule__Field__CrossReferenceAssignment_0_1 ) ) );
    public final void rule__Field__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2398:1: ( ( ( rule__Field__ContainmentAssignment_0_0 ) ) | ( ( rule__Field__CrossReferenceAssignment_0_1 ) ) )
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==Contains) ) {
                alt15=1;
            }
            else if ( (LA15_0==Refers) ) {
                alt15=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }
            switch (alt15) {
                case 1 :
                    // InternalSolverLanguageParser.g:2399:2: ( ( rule__Field__ContainmentAssignment_0_0 ) )
                    {
                    // InternalSolverLanguageParser.g:2399:2: ( ( rule__Field__ContainmentAssignment_0_0 ) )
                    // InternalSolverLanguageParser.g:2400:3: ( rule__Field__ContainmentAssignment_0_0 )
                    {
                     before(grammarAccess.getFieldAccess().getContainmentAssignment_0_0()); 
                    // InternalSolverLanguageParser.g:2401:3: ( rule__Field__ContainmentAssignment_0_0 )
                    // InternalSolverLanguageParser.g:2401:4: rule__Field__ContainmentAssignment_0_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__Field__ContainmentAssignment_0_0();

                    state._fsp--;


                    }

                     after(grammarAccess.getFieldAccess().getContainmentAssignment_0_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2405:2: ( ( rule__Field__CrossReferenceAssignment_0_1 ) )
                    {
                    // InternalSolverLanguageParser.g:2405:2: ( ( rule__Field__CrossReferenceAssignment_0_1 ) )
                    // InternalSolverLanguageParser.g:2406:3: ( rule__Field__CrossReferenceAssignment_0_1 )
                    {
                     before(grammarAccess.getFieldAccess().getCrossReferenceAssignment_0_1()); 
                    // InternalSolverLanguageParser.g:2407:3: ( rule__Field__CrossReferenceAssignment_0_1 )
                    // InternalSolverLanguageParser.g:2407:4: rule__Field__CrossReferenceAssignment_0_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__Field__CrossReferenceAssignment_0_1();

                    state._fsp--;


                    }

                     after(grammarAccess.getFieldAccess().getCrossReferenceAssignment_0_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Multiplicity__Alternatives"
    // InternalSolverLanguageParser.g:2415:1: rule__Multiplicity__Alternatives : ( ( ruleUnboundedMultiplicity ) | ( ruleExactMultiplicity ) | ( ruleBoundedMultiplicity ) );
    public final void rule__Multiplicity__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2419:1: ( ( ruleUnboundedMultiplicity ) | ( ruleExactMultiplicity ) | ( ruleBoundedMultiplicity ) )
            int alt16=3;
            int LA16_0 = input.LA(1);

            if ( (LA16_0==LeftSquareBracket) ) {
                switch ( input.LA(2) ) {
                case RULE_INT:
                    {
                    int LA16_2 = input.LA(3);

                    if ( (LA16_2==Comma) ) {
                        alt16=3;
                    }
                    else if ( (LA16_2==RightSquareBracket) ) {
                        alt16=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 16, 2, input);

                        throw nvae;
                    }
                    }
                    break;
                case Asterisk:
                    {
                    alt16=2;
                    }
                    break;
                case RightSquareBracket:
                    {
                    alt16=1;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 1, input);

                    throw nvae;
                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }
            switch (alt16) {
                case 1 :
                    // InternalSolverLanguageParser.g:2420:2: ( ruleUnboundedMultiplicity )
                    {
                    // InternalSolverLanguageParser.g:2420:2: ( ruleUnboundedMultiplicity )
                    // InternalSolverLanguageParser.g:2421:3: ruleUnboundedMultiplicity
                    {
                     before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleUnboundedMultiplicity();

                    state._fsp--;

                     after(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2426:2: ( ruleExactMultiplicity )
                    {
                    // InternalSolverLanguageParser.g:2426:2: ( ruleExactMultiplicity )
                    // InternalSolverLanguageParser.g:2427:3: ruleExactMultiplicity
                    {
                     before(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleExactMultiplicity();

                    state._fsp--;

                     after(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2432:2: ( ruleBoundedMultiplicity )
                    {
                    // InternalSolverLanguageParser.g:2432:2: ( ruleBoundedMultiplicity )
                    // InternalSolverLanguageParser.g:2433:3: ruleBoundedMultiplicity
                    {
                     before(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleBoundedMultiplicity();

                    state._fsp--;

                     after(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EnumDeclaration__Alternatives_2"
    // InternalSolverLanguageParser.g:2442:1: rule__EnumDeclaration__Alternatives_2 : ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( RULE_FULL_STOP ) );
    public final void rule__EnumDeclaration__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2446:1: ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( RULE_FULL_STOP ) )
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==LeftCurlyBracket) ) {
                alt17=1;
            }
            else if ( (LA17_0==RULE_FULL_STOP) ) {
                alt17=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }
            switch (alt17) {
                case 1 :
                    // InternalSolverLanguageParser.g:2447:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2447:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) )
                    // InternalSolverLanguageParser.g:2448:3: ( rule__EnumDeclaration__Group_2_0__0 )
                    {
                     before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); 
                    // InternalSolverLanguageParser.g:2449:3: ( rule__EnumDeclaration__Group_2_0__0 )
                    // InternalSolverLanguageParser.g:2449:4: rule__EnumDeclaration__Group_2_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__EnumDeclaration__Group_2_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2453:2: ( RULE_FULL_STOP )
                    {
                    // InternalSolverLanguageParser.g:2453:2: ( RULE_FULL_STOP )
                    // InternalSolverLanguageParser.g:2454:3: RULE_FULL_STOP
                    {
                     before(grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); 
                    match(input,RULE_FULL_STOP,FOLLOW_2); 
                     after(grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ScopeDeclaration__Alternatives"
    // InternalSolverLanguageParser.g:2463:1: rule__ScopeDeclaration__Alternatives : ( ( ruleExactScope ) | ( ruleBoundedScope ) | ( ruleLowerBoundedScope ) );
    public final void rule__ScopeDeclaration__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2467:1: ( ( ruleExactScope ) | ( ruleBoundedScope ) | ( ruleLowerBoundedScope ) )
            int alt18=3;
            alt18 = dfa18.predict(input);
            switch (alt18) {
                case 1 :
                    // InternalSolverLanguageParser.g:2468:2: ( ruleExactScope )
                    {
                    // InternalSolverLanguageParser.g:2468:2: ( ruleExactScope )
                    // InternalSolverLanguageParser.g:2469:3: ruleExactScope
                    {
                     before(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); 
                    pushFollow(FOLLOW_2);
                    ruleExactScope();

                    state._fsp--;

                     after(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2474:2: ( ruleBoundedScope )
                    {
                    // InternalSolverLanguageParser.g:2474:2: ( ruleBoundedScope )
                    // InternalSolverLanguageParser.g:2475:3: ruleBoundedScope
                    {
                     before(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); 
                    pushFollow(FOLLOW_2);
                    ruleBoundedScope();

                    state._fsp--;

                     after(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2480:2: ( ruleLowerBoundedScope )
                    {
                    // InternalSolverLanguageParser.g:2480:2: ( ruleLowerBoundedScope )
                    // InternalSolverLanguageParser.g:2481:3: ruleLowerBoundedScope
                    {
                     before(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); 
                    pushFollow(FOLLOW_2);
                    ruleLowerBoundedScope();

                    state._fsp--;

                     after(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__BoundedScope__Alternatives_1"
    // InternalSolverLanguageParser.g:2490:1: rule__BoundedScope__Alternatives_1 : ( ( ( rule__BoundedScope__Group_1_0__0 ) ) | ( ( rule__BoundedScope__Group_1_1__0 ) ) );
    public final void rule__BoundedScope__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2494:1: ( ( ( rule__BoundedScope__Group_1_0__0 ) ) | ( ( rule__BoundedScope__Group_1_1__0 ) ) )
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==RULE_INT) ) {
                int LA19_1 = input.LA(2);

                if ( (LA19_1==LessThanSignEqualsSign) ) {
                    alt19=1;
                }
                else if ( (LA19_1==GreaterThanSignEqualsSign) ) {
                    alt19=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 19, 1, input);

                    throw nvae;
                }
            }
            else if ( (LA19_0==Object||LA19_0==RULE_QUOTED_ID||LA19_0==RULE_ID) ) {
                alt19=1;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                throw nvae;
            }
            switch (alt19) {
                case 1 :
                    // InternalSolverLanguageParser.g:2495:2: ( ( rule__BoundedScope__Group_1_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2495:2: ( ( rule__BoundedScope__Group_1_0__0 ) )
                    // InternalSolverLanguageParser.g:2496:3: ( rule__BoundedScope__Group_1_0__0 )
                    {
                     before(grammarAccess.getBoundedScopeAccess().getGroup_1_0()); 
                    // InternalSolverLanguageParser.g:2497:3: ( rule__BoundedScope__Group_1_0__0 )
                    // InternalSolverLanguageParser.g:2497:4: rule__BoundedScope__Group_1_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__BoundedScope__Group_1_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getBoundedScopeAccess().getGroup_1_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2501:2: ( ( rule__BoundedScope__Group_1_1__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2501:2: ( ( rule__BoundedScope__Group_1_1__0 ) )
                    // InternalSolverLanguageParser.g:2502:3: ( rule__BoundedScope__Group_1_1__0 )
                    {
                     before(grammarAccess.getBoundedScopeAccess().getGroup_1_1()); 
                    // InternalSolverLanguageParser.g:2503:3: ( rule__BoundedScope__Group_1_1__0 )
                    // InternalSolverLanguageParser.g:2503:4: rule__BoundedScope__Group_1_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__BoundedScope__Group_1_1__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getBoundedScopeAccess().getGroup_1_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LowerBoundedScope__Alternatives_1"
    // InternalSolverLanguageParser.g:2511:1: rule__LowerBoundedScope__Alternatives_1 : ( ( ( rule__LowerBoundedScope__Group_1_0__0 ) ) | ( ( rule__LowerBoundedScope__Group_1_1__0 ) ) );
    public final void rule__LowerBoundedScope__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2515:1: ( ( ( rule__LowerBoundedScope__Group_1_0__0 ) ) | ( ( rule__LowerBoundedScope__Group_1_1__0 ) ) )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==RULE_INT) ) {
                alt20=1;
            }
            else if ( (LA20_0==Object||LA20_0==RULE_QUOTED_ID||LA20_0==RULE_ID) ) {
                alt20=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }
            switch (alt20) {
                case 1 :
                    // InternalSolverLanguageParser.g:2516:2: ( ( rule__LowerBoundedScope__Group_1_0__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2516:2: ( ( rule__LowerBoundedScope__Group_1_0__0 ) )
                    // InternalSolverLanguageParser.g:2517:3: ( rule__LowerBoundedScope__Group_1_0__0 )
                    {
                     before(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_0()); 
                    // InternalSolverLanguageParser.g:2518:3: ( rule__LowerBoundedScope__Group_1_0__0 )
                    // InternalSolverLanguageParser.g:2518:4: rule__LowerBoundedScope__Group_1_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LowerBoundedScope__Group_1_0__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2522:2: ( ( rule__LowerBoundedScope__Group_1_1__0 ) )
                    {
                    // InternalSolverLanguageParser.g:2522:2: ( ( rule__LowerBoundedScope__Group_1_1__0 ) )
                    // InternalSolverLanguageParser.g:2523:3: ( rule__LowerBoundedScope__Group_1_1__0 )
                    {
                     before(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_1()); 
                    // InternalSolverLanguageParser.g:2524:3: ( rule__LowerBoundedScope__Group_1_1__0 )
                    // InternalSolverLanguageParser.g:2524:4: rule__LowerBoundedScope__Group_1_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LowerBoundedScope__Group_1_1__0();

                    state._fsp--;


                    }

                     after(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UpperMultiplicty__Alternatives"
    // InternalSolverLanguageParser.g:2532:1: rule__UpperMultiplicty__Alternatives : ( ( RULE_INT ) | ( Asterisk ) );
    public final void rule__UpperMultiplicty__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2536:1: ( ( RULE_INT ) | ( Asterisk ) )
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0==RULE_INT) ) {
                alt21=1;
            }
            else if ( (LA21_0==Asterisk) ) {
                alt21=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;
            }
            switch (alt21) {
                case 1 :
                    // InternalSolverLanguageParser.g:2537:2: ( RULE_INT )
                    {
                    // InternalSolverLanguageParser.g:2537:2: ( RULE_INT )
                    // InternalSolverLanguageParser.g:2538:3: RULE_INT
                    {
                     before(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); 
                    match(input,RULE_INT,FOLLOW_2); 
                     after(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2543:2: ( Asterisk )
                    {
                    // InternalSolverLanguageParser.g:2543:2: ( Asterisk )
                    // InternalSolverLanguageParser.g:2544:3: Asterisk
                    {
                     before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); 
                    match(input,Asterisk,FOLLOW_2); 
                     after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__QualifiedNameSegment__Alternatives"
    // InternalSolverLanguageParser.g:2553:1: rule__QualifiedNameSegment__Alternatives : ( ( RULE_ID ) | ( RULE_QUOTED_ID ) | ( Object ) );
    public final void rule__QualifiedNameSegment__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2557:1: ( ( RULE_ID ) | ( RULE_QUOTED_ID ) | ( Object ) )
            int alt22=3;
            switch ( input.LA(1) ) {
            case RULE_ID:
                {
                alt22=1;
                }
                break;
            case RULE_QUOTED_ID:
                {
                alt22=2;
                }
                break;
            case Object:
                {
                alt22=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }

            switch (alt22) {
                case 1 :
                    // InternalSolverLanguageParser.g:2558:2: ( RULE_ID )
                    {
                    // InternalSolverLanguageParser.g:2558:2: ( RULE_ID )
                    // InternalSolverLanguageParser.g:2559:3: RULE_ID
                    {
                     before(grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); 
                    match(input,RULE_ID,FOLLOW_2); 
                     after(grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2564:2: ( RULE_QUOTED_ID )
                    {
                    // InternalSolverLanguageParser.g:2564:2: ( RULE_QUOTED_ID )
                    // InternalSolverLanguageParser.g:2565:3: RULE_QUOTED_ID
                    {
                     before(grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); 
                    match(input,RULE_QUOTED_ID,FOLLOW_2); 
                     after(grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2570:2: ( Object )
                    {
                    // InternalSolverLanguageParser.g:2570:2: ( Object )
                    // InternalSolverLanguageParser.g:2571:3: Object
                    {
                     before(grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); 
                    match(input,Object,FOLLOW_2); 
                     after(grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AttributeKind__Alternatives"
    // InternalSolverLanguageParser.g:2580:1: rule__AttributeKind__Alternatives : ( ( ( Functional ) ) | ( ( Error ) ) | ( ( Root ) ) | ( ( Containment ) ) );
    public final void rule__AttributeKind__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2584:1: ( ( ( Functional ) ) | ( ( Error ) ) | ( ( Root ) ) | ( ( Containment ) ) )
            int alt23=4;
            switch ( input.LA(1) ) {
            case Functional:
                {
                alt23=1;
                }
                break;
            case Error:
                {
                alt23=2;
                }
                break;
            case Root:
                {
                alt23=3;
                }
                break;
            case Containment:
                {
                alt23=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }

            switch (alt23) {
                case 1 :
                    // InternalSolverLanguageParser.g:2585:2: ( ( Functional ) )
                    {
                    // InternalSolverLanguageParser.g:2585:2: ( ( Functional ) )
                    // InternalSolverLanguageParser.g:2586:3: ( Functional )
                    {
                     before(grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2587:3: ( Functional )
                    // InternalSolverLanguageParser.g:2587:4: Functional
                    {
                    match(input,Functional,FOLLOW_2); 

                    }

                     after(grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2591:2: ( ( Error ) )
                    {
                    // InternalSolverLanguageParser.g:2591:2: ( ( Error ) )
                    // InternalSolverLanguageParser.g:2592:3: ( Error )
                    {
                     before(grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2593:3: ( Error )
                    // InternalSolverLanguageParser.g:2593:4: Error
                    {
                    match(input,Error,FOLLOW_2); 

                    }

                     after(grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2597:2: ( ( Root ) )
                    {
                    // InternalSolverLanguageParser.g:2597:2: ( ( Root ) )
                    // InternalSolverLanguageParser.g:2598:3: ( Root )
                    {
                     before(grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); 
                    // InternalSolverLanguageParser.g:2599:3: ( Root )
                    // InternalSolverLanguageParser.g:2599:4: Root
                    {
                    match(input,Root,FOLLOW_2); 

                    }

                     after(grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2603:2: ( ( Containment ) )
                    {
                    // InternalSolverLanguageParser.g:2603:2: ( ( Containment ) )
                    // InternalSolverLanguageParser.g:2604:3: ( Containment )
                    {
                     before(grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); 
                    // InternalSolverLanguageParser.g:2605:3: ( Containment )
                    // InternalSolverLanguageParser.g:2605:4: Containment
                    {
                    match(input,Containment,FOLLOW_2); 

                    }

                     after(grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonOperator__Alternatives"
    // InternalSolverLanguageParser.g:2613:1: rule__ComparisonOperator__Alternatives : ( ( ( EqualsSignEqualsSign ) ) | ( ( ExclamationMarkEqualsSign ) ) | ( ( LessThanSign ) ) | ( ( LessThanSignEqualsSign ) ) | ( ( GreaterThanSign ) ) | ( ( GreaterThanSignEqualsSign ) ) | ( ( In ) ) );
    public final void rule__ComparisonOperator__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2617:1: ( ( ( EqualsSignEqualsSign ) ) | ( ( ExclamationMarkEqualsSign ) ) | ( ( LessThanSign ) ) | ( ( LessThanSignEqualsSign ) ) | ( ( GreaterThanSign ) ) | ( ( GreaterThanSignEqualsSign ) ) | ( ( In ) ) )
            int alt24=7;
            switch ( input.LA(1) ) {
            case EqualsSignEqualsSign:
                {
                alt24=1;
                }
                break;
            case ExclamationMarkEqualsSign:
                {
                alt24=2;
                }
                break;
            case LessThanSign:
                {
                alt24=3;
                }
                break;
            case LessThanSignEqualsSign:
                {
                alt24=4;
                }
                break;
            case GreaterThanSign:
                {
                alt24=5;
                }
                break;
            case GreaterThanSignEqualsSign:
                {
                alt24=6;
                }
                break;
            case In:
                {
                alt24=7;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                throw nvae;
            }

            switch (alt24) {
                case 1 :
                    // InternalSolverLanguageParser.g:2618:2: ( ( EqualsSignEqualsSign ) )
                    {
                    // InternalSolverLanguageParser.g:2618:2: ( ( EqualsSignEqualsSign ) )
                    // InternalSolverLanguageParser.g:2619:3: ( EqualsSignEqualsSign )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2620:3: ( EqualsSignEqualsSign )
                    // InternalSolverLanguageParser.g:2620:4: EqualsSignEqualsSign
                    {
                    match(input,EqualsSignEqualsSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2624:2: ( ( ExclamationMarkEqualsSign ) )
                    {
                    // InternalSolverLanguageParser.g:2624:2: ( ( ExclamationMarkEqualsSign ) )
                    // InternalSolverLanguageParser.g:2625:3: ( ExclamationMarkEqualsSign )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2626:3: ( ExclamationMarkEqualsSign )
                    // InternalSolverLanguageParser.g:2626:4: ExclamationMarkEqualsSign
                    {
                    match(input,ExclamationMarkEqualsSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2630:2: ( ( LessThanSign ) )
                    {
                    // InternalSolverLanguageParser.g:2630:2: ( ( LessThanSign ) )
                    // InternalSolverLanguageParser.g:2631:3: ( LessThanSign )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); 
                    // InternalSolverLanguageParser.g:2632:3: ( LessThanSign )
                    // InternalSolverLanguageParser.g:2632:4: LessThanSign
                    {
                    match(input,LessThanSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2636:2: ( ( LessThanSignEqualsSign ) )
                    {
                    // InternalSolverLanguageParser.g:2636:2: ( ( LessThanSignEqualsSign ) )
                    // InternalSolverLanguageParser.g:2637:3: ( LessThanSignEqualsSign )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); 
                    // InternalSolverLanguageParser.g:2638:3: ( LessThanSignEqualsSign )
                    // InternalSolverLanguageParser.g:2638:4: LessThanSignEqualsSign
                    {
                    match(input,LessThanSignEqualsSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); 

                    }


                    }
                    break;
                case 5 :
                    // InternalSolverLanguageParser.g:2642:2: ( ( GreaterThanSign ) )
                    {
                    // InternalSolverLanguageParser.g:2642:2: ( ( GreaterThanSign ) )
                    // InternalSolverLanguageParser.g:2643:3: ( GreaterThanSign )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); 
                    // InternalSolverLanguageParser.g:2644:3: ( GreaterThanSign )
                    // InternalSolverLanguageParser.g:2644:4: GreaterThanSign
                    {
                    match(input,GreaterThanSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); 

                    }


                    }
                    break;
                case 6 :
                    // InternalSolverLanguageParser.g:2648:2: ( ( GreaterThanSignEqualsSign ) )
                    {
                    // InternalSolverLanguageParser.g:2648:2: ( ( GreaterThanSignEqualsSign ) )
                    // InternalSolverLanguageParser.g:2649:3: ( GreaterThanSignEqualsSign )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); 
                    // InternalSolverLanguageParser.g:2650:3: ( GreaterThanSignEqualsSign )
                    // InternalSolverLanguageParser.g:2650:4: GreaterThanSignEqualsSign
                    {
                    match(input,GreaterThanSignEqualsSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); 

                    }


                    }
                    break;
                case 7 :
                    // InternalSolverLanguageParser.g:2654:2: ( ( In ) )
                    {
                    // InternalSolverLanguageParser.g:2654:2: ( ( In ) )
                    // InternalSolverLanguageParser.g:2655:3: ( In )
                    {
                     before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); 
                    // InternalSolverLanguageParser.g:2656:3: ( In )
                    // InternalSolverLanguageParser.g:2656:4: In
                    {
                    match(input,In,FOLLOW_2); 

                    }

                     after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AdditiveBinaryOperator__Alternatives"
    // InternalSolverLanguageParser.g:2664:1: rule__AdditiveBinaryOperator__Alternatives : ( ( ( PlusSign ) ) | ( ( HyphenMinus ) ) );
    public final void rule__AdditiveBinaryOperator__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2668:1: ( ( ( PlusSign ) ) | ( ( HyphenMinus ) ) )
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==PlusSign) ) {
                alt25=1;
            }
            else if ( (LA25_0==HyphenMinus) ) {
                alt25=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }
            switch (alt25) {
                case 1 :
                    // InternalSolverLanguageParser.g:2669:2: ( ( PlusSign ) )
                    {
                    // InternalSolverLanguageParser.g:2669:2: ( ( PlusSign ) )
                    // InternalSolverLanguageParser.g:2670:3: ( PlusSign )
                    {
                     before(grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2671:3: ( PlusSign )
                    // InternalSolverLanguageParser.g:2671:4: PlusSign
                    {
                    match(input,PlusSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2675:2: ( ( HyphenMinus ) )
                    {
                    // InternalSolverLanguageParser.g:2675:2: ( ( HyphenMinus ) )
                    // InternalSolverLanguageParser.g:2676:3: ( HyphenMinus )
                    {
                     before(grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2677:3: ( HyphenMinus )
                    // InternalSolverLanguageParser.g:2677:4: HyphenMinus
                    {
                    match(input,HyphenMinus,FOLLOW_2); 

                    }

                     after(grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicativeBinaryOperator__Alternatives"
    // InternalSolverLanguageParser.g:2685:1: rule__MultiplicativeBinaryOperator__Alternatives : ( ( ( Asterisk ) ) | ( ( Solidus ) ) );
    public final void rule__MultiplicativeBinaryOperator__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2689:1: ( ( ( Asterisk ) ) | ( ( Solidus ) ) )
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==Asterisk) ) {
                alt26=1;
            }
            else if ( (LA26_0==Solidus) ) {
                alt26=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;
            }
            switch (alt26) {
                case 1 :
                    // InternalSolverLanguageParser.g:2690:2: ( ( Asterisk ) )
                    {
                    // InternalSolverLanguageParser.g:2690:2: ( ( Asterisk ) )
                    // InternalSolverLanguageParser.g:2691:3: ( Asterisk )
                    {
                     before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2692:3: ( Asterisk )
                    // InternalSolverLanguageParser.g:2692:4: Asterisk
                    {
                    match(input,Asterisk,FOLLOW_2); 

                    }

                     after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2696:2: ( ( Solidus ) )
                    {
                    // InternalSolverLanguageParser.g:2696:2: ( ( Solidus ) )
                    // InternalSolverLanguageParser.g:2697:3: ( Solidus )
                    {
                     before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2698:3: ( Solidus )
                    // InternalSolverLanguageParser.g:2698:4: Solidus
                    {
                    match(input,Solidus,FOLLOW_2); 

                    }

                     after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnaryOperator__Alternatives"
    // InternalSolverLanguageParser.g:2706:1: rule__UnaryOperator__Alternatives : ( ( ( ExclamationMark ) ) | ( ( PlusSign ) ) | ( ( HyphenMinus ) ) | ( ( QuestionMark ) ) );
    public final void rule__UnaryOperator__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2710:1: ( ( ( ExclamationMark ) ) | ( ( PlusSign ) ) | ( ( HyphenMinus ) ) | ( ( QuestionMark ) ) )
            int alt27=4;
            switch ( input.LA(1) ) {
            case ExclamationMark:
                {
                alt27=1;
                }
                break;
            case PlusSign:
                {
                alt27=2;
                }
                break;
            case HyphenMinus:
                {
                alt27=3;
                }
                break;
            case QuestionMark:
                {
                alt27=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 27, 0, input);

                throw nvae;
            }

            switch (alt27) {
                case 1 :
                    // InternalSolverLanguageParser.g:2711:2: ( ( ExclamationMark ) )
                    {
                    // InternalSolverLanguageParser.g:2711:2: ( ( ExclamationMark ) )
                    // InternalSolverLanguageParser.g:2712:3: ( ExclamationMark )
                    {
                     before(grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2713:3: ( ExclamationMark )
                    // InternalSolverLanguageParser.g:2713:4: ExclamationMark
                    {
                    match(input,ExclamationMark,FOLLOW_2); 

                    }

                     after(grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2717:2: ( ( PlusSign ) )
                    {
                    // InternalSolverLanguageParser.g:2717:2: ( ( PlusSign ) )
                    // InternalSolverLanguageParser.g:2718:3: ( PlusSign )
                    {
                     before(grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2719:3: ( PlusSign )
                    // InternalSolverLanguageParser.g:2719:4: PlusSign
                    {
                    match(input,PlusSign,FOLLOW_2); 

                    }

                     after(grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2723:2: ( ( HyphenMinus ) )
                    {
                    // InternalSolverLanguageParser.g:2723:2: ( ( HyphenMinus ) )
                    // InternalSolverLanguageParser.g:2724:3: ( HyphenMinus )
                    {
                     before(grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); 
                    // InternalSolverLanguageParser.g:2725:3: ( HyphenMinus )
                    // InternalSolverLanguageParser.g:2725:4: HyphenMinus
                    {
                    match(input,HyphenMinus,FOLLOW_2); 

                    }

                     after(grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2729:2: ( ( QuestionMark ) )
                    {
                    // InternalSolverLanguageParser.g:2729:2: ( ( QuestionMark ) )
                    // InternalSolverLanguageParser.g:2730:3: ( QuestionMark )
                    {
                     before(grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); 
                    // InternalSolverLanguageParser.g:2731:3: ( QuestionMark )
                    // InternalSolverLanguageParser.g:2731:4: QuestionMark
                    {
                    match(input,QuestionMark,FOLLOW_2); 

                    }

                     after(grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LogicValue__Alternatives"
    // InternalSolverLanguageParser.g:2739:1: rule__LogicValue__Alternatives : ( ( ( True ) ) | ( ( False ) ) | ( ( Unknown ) ) | ( ( Error ) ) );
    public final void rule__LogicValue__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2743:1: ( ( ( True ) ) | ( ( False ) ) | ( ( Unknown ) ) | ( ( Error ) ) )
            int alt28=4;
            switch ( input.LA(1) ) {
            case True:
                {
                alt28=1;
                }
                break;
            case False:
                {
                alt28=2;
                }
                break;
            case Unknown:
                {
                alt28=3;
                }
                break;
            case Error:
                {
                alt28=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                throw nvae;
            }

            switch (alt28) {
                case 1 :
                    // InternalSolverLanguageParser.g:2744:2: ( ( True ) )
                    {
                    // InternalSolverLanguageParser.g:2744:2: ( ( True ) )
                    // InternalSolverLanguageParser.g:2745:3: ( True )
                    {
                     before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2746:3: ( True )
                    // InternalSolverLanguageParser.g:2746:4: True
                    {
                    match(input,True,FOLLOW_2); 

                    }

                     after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2750:2: ( ( False ) )
                    {
                    // InternalSolverLanguageParser.g:2750:2: ( ( False ) )
                    // InternalSolverLanguageParser.g:2751:3: ( False )
                    {
                     before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2752:3: ( False )
                    // InternalSolverLanguageParser.g:2752:4: False
                    {
                    match(input,False,FOLLOW_2); 

                    }

                     after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); 

                    }


                    }
                    break;
                case 3 :
                    // InternalSolverLanguageParser.g:2756:2: ( ( Unknown ) )
                    {
                    // InternalSolverLanguageParser.g:2756:2: ( ( Unknown ) )
                    // InternalSolverLanguageParser.g:2757:3: ( Unknown )
                    {
                     before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); 
                    // InternalSolverLanguageParser.g:2758:3: ( Unknown )
                    // InternalSolverLanguageParser.g:2758:4: Unknown
                    {
                    match(input,Unknown,FOLLOW_2); 

                    }

                     after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); 

                    }


                    }
                    break;
                case 4 :
                    // InternalSolverLanguageParser.g:2762:2: ( ( Error ) )
                    {
                    // InternalSolverLanguageParser.g:2762:2: ( ( Error ) )
                    // InternalSolverLanguageParser.g:2763:3: ( Error )
                    {
                     before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); 
                    // InternalSolverLanguageParser.g:2764:3: ( Error )
                    // InternalSolverLanguageParser.g:2764:4: Error
                    {
                    match(input,Error,FOLLOW_2); 

                    }

                     after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ObjectiveKind__Alternatives"
    // InternalSolverLanguageParser.g:2772:1: rule__ObjectiveKind__Alternatives : ( ( ( Minimize ) ) | ( ( Maximize ) ) );
    public final void rule__ObjectiveKind__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2776:1: ( ( ( Minimize ) ) | ( ( Maximize ) ) )
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==Minimize) ) {
                alt29=1;
            }
            else if ( (LA29_0==Maximize) ) {
                alt29=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }
            switch (alt29) {
                case 1 :
                    // InternalSolverLanguageParser.g:2777:2: ( ( Minimize ) )
                    {
                    // InternalSolverLanguageParser.g:2777:2: ( ( Minimize ) )
                    // InternalSolverLanguageParser.g:2778:3: ( Minimize )
                    {
                     before(grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); 
                    // InternalSolverLanguageParser.g:2779:3: ( Minimize )
                    // InternalSolverLanguageParser.g:2779:4: Minimize
                    {
                    match(input,Minimize,FOLLOW_2); 

                    }

                     after(grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); 

                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:2783:2: ( ( Maximize ) )
                    {
                    // InternalSolverLanguageParser.g:2783:2: ( ( Maximize ) )
                    // InternalSolverLanguageParser.g:2784:3: ( Maximize )
                    {
                     before(grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); 
                    // InternalSolverLanguageParser.g:2785:3: ( Maximize )
                    // InternalSolverLanguageParser.g:2785:4: Maximize
                    {
                    match(input,Maximize,FOLLOW_2); 

                    }

                     after(grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); 

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group__0"
    // InternalSolverLanguageParser.g:2793:1: rule__Problem__Group__0 : rule__Problem__Group__0__Impl rule__Problem__Group__1 ;
    public final void rule__Problem__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2797:1: ( rule__Problem__Group__0__Impl rule__Problem__Group__1 )
            // InternalSolverLanguageParser.g:2798:2: rule__Problem__Group__0__Impl rule__Problem__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__Problem__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Problem__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group__0__Impl"
    // InternalSolverLanguageParser.g:2805:1: rule__Problem__Group__0__Impl : ( ( rule__Problem__Group_0__0 )? ) ;
    public final void rule__Problem__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2809:1: ( ( ( rule__Problem__Group_0__0 )? ) )
            // InternalSolverLanguageParser.g:2810:1: ( ( rule__Problem__Group_0__0 )? )
            {
            // InternalSolverLanguageParser.g:2810:1: ( ( rule__Problem__Group_0__0 )? )
            // InternalSolverLanguageParser.g:2811:2: ( rule__Problem__Group_0__0 )?
            {
             before(grammarAccess.getProblemAccess().getGroup_0()); 
            // InternalSolverLanguageParser.g:2812:2: ( rule__Problem__Group_0__0 )?
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==Problem) ) {
                alt30=1;
            }
            switch (alt30) {
                case 1 :
                    // InternalSolverLanguageParser.g:2812:3: rule__Problem__Group_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__Problem__Group_0__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getProblemAccess().getGroup_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group__1"
    // InternalSolverLanguageParser.g:2820:1: rule__Problem__Group__1 : rule__Problem__Group__1__Impl rule__Problem__Group__2 ;
    public final void rule__Problem__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2824:1: ( rule__Problem__Group__1__Impl rule__Problem__Group__2 )
            // InternalSolverLanguageParser.g:2825:2: rule__Problem__Group__1__Impl rule__Problem__Group__2
            {
            pushFollow(FOLLOW_3);
            rule__Problem__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Problem__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group__1__Impl"
    // InternalSolverLanguageParser.g:2832:1: rule__Problem__Group__1__Impl : ( ( rule__Problem__ImportsAssignment_1 )* ) ;
    public final void rule__Problem__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2836:1: ( ( ( rule__Problem__ImportsAssignment_1 )* ) )
            // InternalSolverLanguageParser.g:2837:1: ( ( rule__Problem__ImportsAssignment_1 )* )
            {
            // InternalSolverLanguageParser.g:2837:1: ( ( rule__Problem__ImportsAssignment_1 )* )
            // InternalSolverLanguageParser.g:2838:2: ( rule__Problem__ImportsAssignment_1 )*
            {
             before(grammarAccess.getProblemAccess().getImportsAssignment_1()); 
            // InternalSolverLanguageParser.g:2839:2: ( rule__Problem__ImportsAssignment_1 )*
            loop31:
            do {
                int alt31=2;
                int LA31_0 = input.LA(1);

                if ( (LA31_0==Import) ) {
                    alt31=1;
                }


                switch (alt31) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:2839:3: rule__Problem__ImportsAssignment_1
            	    {
            	    pushFollow(FOLLOW_4);
            	    rule__Problem__ImportsAssignment_1();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop31;
                }
            } while (true);

             after(grammarAccess.getProblemAccess().getImportsAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group__2"
    // InternalSolverLanguageParser.g:2847:1: rule__Problem__Group__2 : rule__Problem__Group__2__Impl ;
    public final void rule__Problem__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2851:1: ( rule__Problem__Group__2__Impl )
            // InternalSolverLanguageParser.g:2852:2: rule__Problem__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Problem__Group__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group__2__Impl"
    // InternalSolverLanguageParser.g:2858:1: rule__Problem__Group__2__Impl : ( ( rule__Problem__StatementsAssignment_2 )* ) ;
    public final void rule__Problem__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2862:1: ( ( ( rule__Problem__StatementsAssignment_2 )* ) )
            // InternalSolverLanguageParser.g:2863:1: ( ( rule__Problem__StatementsAssignment_2 )* )
            {
            // InternalSolverLanguageParser.g:2863:1: ( ( rule__Problem__StatementsAssignment_2 )* )
            // InternalSolverLanguageParser.g:2864:2: ( rule__Problem__StatementsAssignment_2 )*
            {
             before(grammarAccess.getProblemAccess().getStatementsAssignment_2()); 
            // InternalSolverLanguageParser.g:2865:2: ( rule__Problem__StatementsAssignment_2 )*
            loop32:
            do {
                int alt32=2;
                int LA32_0 = input.LA(1);

                if ( ((LA32_0>=Containment && LA32_0<=Abstract)||(LA32_0>=Maximize && LA32_0<=Minimize)||LA32_0==Default||(LA32_0>=Unknown && LA32_0<=Extern)||LA32_0==Object||(LA32_0>=Class && LA32_0<=Scope)||(LA32_0>=Enum && LA32_0<=Root)||LA32_0==True||(LA32_0>=Inf && LA32_0<=Let)||LA32_0==If||(LA32_0>=ExclamationMark && LA32_0<=LeftParenthesis)||LA32_0==PlusSign||LA32_0==HyphenMinus||(LA32_0>=QuestionMark && LA32_0<=LeftSquareBracket)||(LA32_0>=Tilde && LA32_0<=RULE_QUOTED_ID)||(LA32_0>=RULE_ID && LA32_0<=RULE_INT)) ) {
                    alt32=1;
                }


                switch (alt32) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:2865:3: rule__Problem__StatementsAssignment_2
            	    {
            	    pushFollow(FOLLOW_5);
            	    rule__Problem__StatementsAssignment_2();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop32;
                }
            } while (true);

             after(grammarAccess.getProblemAccess().getStatementsAssignment_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group_0__0"
    // InternalSolverLanguageParser.g:2874:1: rule__Problem__Group_0__0 : rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ;
    public final void rule__Problem__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2878:1: ( rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 )
            // InternalSolverLanguageParser.g:2879:2: rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1
            {
            pushFollow(FOLLOW_6);
            rule__Problem__Group_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Problem__Group_0__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group_0__0__Impl"
    // InternalSolverLanguageParser.g:2886:1: rule__Problem__Group_0__0__Impl : ( Problem ) ;
    public final void rule__Problem__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2890:1: ( ( Problem ) )
            // InternalSolverLanguageParser.g:2891:1: ( Problem )
            {
            // InternalSolverLanguageParser.g:2891:1: ( Problem )
            // InternalSolverLanguageParser.g:2892:2: Problem
            {
             before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); 
            match(input,Problem,FOLLOW_2); 
             after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group_0__1"
    // InternalSolverLanguageParser.g:2901:1: rule__Problem__Group_0__1 : rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ;
    public final void rule__Problem__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2905:1: ( rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 )
            // InternalSolverLanguageParser.g:2906:2: rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2
            {
            pushFollow(FOLLOW_7);
            rule__Problem__Group_0__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Problem__Group_0__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group_0__1__Impl"
    // InternalSolverLanguageParser.g:2913:1: rule__Problem__Group_0__1__Impl : ( ( rule__Problem__NameAssignment_0_1 ) ) ;
    public final void rule__Problem__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2917:1: ( ( ( rule__Problem__NameAssignment_0_1 ) ) )
            // InternalSolverLanguageParser.g:2918:1: ( ( rule__Problem__NameAssignment_0_1 ) )
            {
            // InternalSolverLanguageParser.g:2918:1: ( ( rule__Problem__NameAssignment_0_1 ) )
            // InternalSolverLanguageParser.g:2919:2: ( rule__Problem__NameAssignment_0_1 )
            {
             before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); 
            // InternalSolverLanguageParser.g:2920:2: ( rule__Problem__NameAssignment_0_1 )
            // InternalSolverLanguageParser.g:2920:3: rule__Problem__NameAssignment_0_1
            {
            pushFollow(FOLLOW_2);
            rule__Problem__NameAssignment_0_1();

            state._fsp--;


            }

             after(grammarAccess.getProblemAccess().getNameAssignment_0_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group_0__2"
    // InternalSolverLanguageParser.g:2928:1: rule__Problem__Group_0__2 : rule__Problem__Group_0__2__Impl ;
    public final void rule__Problem__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2932:1: ( rule__Problem__Group_0__2__Impl )
            // InternalSolverLanguageParser.g:2933:2: rule__Problem__Group_0__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Problem__Group_0__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Problem__Group_0__2__Impl"
    // InternalSolverLanguageParser.g:2939:1: rule__Problem__Group_0__2__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__Problem__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2943:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:2944:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:2944:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:2945:2: RULE_FULL_STOP
            {
             before(grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__0"
    // InternalSolverLanguageParser.g:2955:1: rule__UriImport__Group__0 : rule__UriImport__Group__0__Impl rule__UriImport__Group__1 ;
    public final void rule__UriImport__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2959:1: ( rule__UriImport__Group__0__Impl rule__UriImport__Group__1 )
            // InternalSolverLanguageParser.g:2960:2: rule__UriImport__Group__0__Impl rule__UriImport__Group__1
            {
            pushFollow(FOLLOW_8);
            rule__UriImport__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UriImport__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__0__Impl"
    // InternalSolverLanguageParser.g:2967:1: rule__UriImport__Group__0__Impl : ( Import ) ;
    public final void rule__UriImport__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2971:1: ( ( Import ) )
            // InternalSolverLanguageParser.g:2972:1: ( Import )
            {
            // InternalSolverLanguageParser.g:2972:1: ( Import )
            // InternalSolverLanguageParser.g:2973:2: Import
            {
             before(grammarAccess.getUriImportAccess().getImportKeyword_0()); 
            match(input,Import,FOLLOW_2); 
             after(grammarAccess.getUriImportAccess().getImportKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__1"
    // InternalSolverLanguageParser.g:2982:1: rule__UriImport__Group__1 : rule__UriImport__Group__1__Impl rule__UriImport__Group__2 ;
    public final void rule__UriImport__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2986:1: ( rule__UriImport__Group__1__Impl rule__UriImport__Group__2 )
            // InternalSolverLanguageParser.g:2987:2: rule__UriImport__Group__1__Impl rule__UriImport__Group__2
            {
            pushFollow(FOLLOW_9);
            rule__UriImport__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UriImport__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__1__Impl"
    // InternalSolverLanguageParser.g:2994:1: rule__UriImport__Group__1__Impl : ( ( rule__UriImport__UriAssignment_1 ) ) ;
    public final void rule__UriImport__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:2998:1: ( ( ( rule__UriImport__UriAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:2999:1: ( ( rule__UriImport__UriAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:2999:1: ( ( rule__UriImport__UriAssignment_1 ) )
            // InternalSolverLanguageParser.g:3000:2: ( rule__UriImport__UriAssignment_1 )
            {
             before(grammarAccess.getUriImportAccess().getUriAssignment_1()); 
            // InternalSolverLanguageParser.g:3001:2: ( rule__UriImport__UriAssignment_1 )
            // InternalSolverLanguageParser.g:3001:3: rule__UriImport__UriAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__UriImport__UriAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getUriImportAccess().getUriAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__2"
    // InternalSolverLanguageParser.g:3009:1: rule__UriImport__Group__2 : rule__UriImport__Group__2__Impl rule__UriImport__Group__3 ;
    public final void rule__UriImport__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3013:1: ( rule__UriImport__Group__2__Impl rule__UriImport__Group__3 )
            // InternalSolverLanguageParser.g:3014:2: rule__UriImport__Group__2__Impl rule__UriImport__Group__3
            {
            pushFollow(FOLLOW_7);
            rule__UriImport__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UriImport__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__2__Impl"
    // InternalSolverLanguageParser.g:3021:1: rule__UriImport__Group__2__Impl : ( ( rule__UriImport__Group_2__0 ) ) ;
    public final void rule__UriImport__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3025:1: ( ( ( rule__UriImport__Group_2__0 ) ) )
            // InternalSolverLanguageParser.g:3026:1: ( ( rule__UriImport__Group_2__0 ) )
            {
            // InternalSolverLanguageParser.g:3026:1: ( ( rule__UriImport__Group_2__0 ) )
            // InternalSolverLanguageParser.g:3027:2: ( rule__UriImport__Group_2__0 )
            {
             before(grammarAccess.getUriImportAccess().getGroup_2()); 
            // InternalSolverLanguageParser.g:3028:2: ( rule__UriImport__Group_2__0 )
            // InternalSolverLanguageParser.g:3028:3: rule__UriImport__Group_2__0
            {
            pushFollow(FOLLOW_2);
            rule__UriImport__Group_2__0();

            state._fsp--;


            }

             after(grammarAccess.getUriImportAccess().getGroup_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__3"
    // InternalSolverLanguageParser.g:3036:1: rule__UriImport__Group__3 : rule__UriImport__Group__3__Impl ;
    public final void rule__UriImport__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3040:1: ( rule__UriImport__Group__3__Impl )
            // InternalSolverLanguageParser.g:3041:2: rule__UriImport__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UriImport__Group__3__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group__3__Impl"
    // InternalSolverLanguageParser.g:3047:1: rule__UriImport__Group__3__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__UriImport__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3051:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:3052:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:3052:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:3053:2: RULE_FULL_STOP
            {
             before(grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group_2__0"
    // InternalSolverLanguageParser.g:3063:1: rule__UriImport__Group_2__0 : rule__UriImport__Group_2__0__Impl rule__UriImport__Group_2__1 ;
    public final void rule__UriImport__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3067:1: ( rule__UriImport__Group_2__0__Impl rule__UriImport__Group_2__1 )
            // InternalSolverLanguageParser.g:3068:2: rule__UriImport__Group_2__0__Impl rule__UriImport__Group_2__1
            {
            pushFollow(FOLLOW_6);
            rule__UriImport__Group_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UriImport__Group_2__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group_2__0__Impl"
    // InternalSolverLanguageParser.g:3075:1: rule__UriImport__Group_2__0__Impl : ( As ) ;
    public final void rule__UriImport__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3079:1: ( ( As ) )
            // InternalSolverLanguageParser.g:3080:1: ( As )
            {
            // InternalSolverLanguageParser.g:3080:1: ( As )
            // InternalSolverLanguageParser.g:3081:2: As
            {
             before(grammarAccess.getUriImportAccess().getAsKeyword_2_0()); 
            match(input,As,FOLLOW_2); 
             after(grammarAccess.getUriImportAccess().getAsKeyword_2_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group_2__1"
    // InternalSolverLanguageParser.g:3090:1: rule__UriImport__Group_2__1 : rule__UriImport__Group_2__1__Impl ;
    public final void rule__UriImport__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3094:1: ( rule__UriImport__Group_2__1__Impl )
            // InternalSolverLanguageParser.g:3095:2: rule__UriImport__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UriImport__Group_2__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UriImport__Group_2__1__Impl"
    // InternalSolverLanguageParser.g:3101:1: rule__UriImport__Group_2__1__Impl : ( ( rule__UriImport__AliasAssignment_2_1 ) ) ;
    public final void rule__UriImport__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3105:1: ( ( ( rule__UriImport__AliasAssignment_2_1 ) ) )
            // InternalSolverLanguageParser.g:3106:1: ( ( rule__UriImport__AliasAssignment_2_1 ) )
            {
            // InternalSolverLanguageParser.g:3106:1: ( ( rule__UriImport__AliasAssignment_2_1 ) )
            // InternalSolverLanguageParser.g:3107:2: ( rule__UriImport__AliasAssignment_2_1 )
            {
             before(grammarAccess.getUriImportAccess().getAliasAssignment_2_1()); 
            // InternalSolverLanguageParser.g:3108:2: ( rule__UriImport__AliasAssignment_2_1 )
            // InternalSolverLanguageParser.g:3108:3: rule__UriImport__AliasAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__UriImport__AliasAssignment_2_1();

            state._fsp--;


            }

             after(grammarAccess.getUriImportAccess().getAliasAssignment_2_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__0"
    // InternalSolverLanguageParser.g:3117:1: rule__NamespaceImport__Group__0 : rule__NamespaceImport__Group__0__Impl rule__NamespaceImport__Group__1 ;
    public final void rule__NamespaceImport__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3121:1: ( rule__NamespaceImport__Group__0__Impl rule__NamespaceImport__Group__1 )
            // InternalSolverLanguageParser.g:3122:2: rule__NamespaceImport__Group__0__Impl rule__NamespaceImport__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__NamespaceImport__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__0__Impl"
    // InternalSolverLanguageParser.g:3129:1: rule__NamespaceImport__Group__0__Impl : ( Import ) ;
    public final void rule__NamespaceImport__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3133:1: ( ( Import ) )
            // InternalSolverLanguageParser.g:3134:1: ( Import )
            {
            // InternalSolverLanguageParser.g:3134:1: ( Import )
            // InternalSolverLanguageParser.g:3135:2: Import
            {
             before(grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); 
            match(input,Import,FOLLOW_2); 
             after(grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__1"
    // InternalSolverLanguageParser.g:3144:1: rule__NamespaceImport__Group__1 : rule__NamespaceImport__Group__1__Impl rule__NamespaceImport__Group__2 ;
    public final void rule__NamespaceImport__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3148:1: ( rule__NamespaceImport__Group__1__Impl rule__NamespaceImport__Group__2 )
            // InternalSolverLanguageParser.g:3149:2: rule__NamespaceImport__Group__1__Impl rule__NamespaceImport__Group__2
            {
            pushFollow(FOLLOW_9);
            rule__NamespaceImport__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__1__Impl"
    // InternalSolverLanguageParser.g:3156:1: rule__NamespaceImport__Group__1__Impl : ( ( rule__NamespaceImport__ImportedNamespaceAssignment_1 ) ) ;
    public final void rule__NamespaceImport__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3160:1: ( ( ( rule__NamespaceImport__ImportedNamespaceAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:3161:1: ( ( rule__NamespaceImport__ImportedNamespaceAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:3161:1: ( ( rule__NamespaceImport__ImportedNamespaceAssignment_1 ) )
            // InternalSolverLanguageParser.g:3162:2: ( rule__NamespaceImport__ImportedNamespaceAssignment_1 )
            {
             before(grammarAccess.getNamespaceImportAccess().getImportedNamespaceAssignment_1()); 
            // InternalSolverLanguageParser.g:3163:2: ( rule__NamespaceImport__ImportedNamespaceAssignment_1 )
            // InternalSolverLanguageParser.g:3163:3: rule__NamespaceImport__ImportedNamespaceAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__NamespaceImport__ImportedNamespaceAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getNamespaceImportAccess().getImportedNamespaceAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__2"
    // InternalSolverLanguageParser.g:3171:1: rule__NamespaceImport__Group__2 : rule__NamespaceImport__Group__2__Impl rule__NamespaceImport__Group__3 ;
    public final void rule__NamespaceImport__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3175:1: ( rule__NamespaceImport__Group__2__Impl rule__NamespaceImport__Group__3 )
            // InternalSolverLanguageParser.g:3176:2: rule__NamespaceImport__Group__2__Impl rule__NamespaceImport__Group__3
            {
            pushFollow(FOLLOW_7);
            rule__NamespaceImport__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__2__Impl"
    // InternalSolverLanguageParser.g:3183:1: rule__NamespaceImport__Group__2__Impl : ( ( rule__NamespaceImport__Group_2__0 ) ) ;
    public final void rule__NamespaceImport__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3187:1: ( ( ( rule__NamespaceImport__Group_2__0 ) ) )
            // InternalSolverLanguageParser.g:3188:1: ( ( rule__NamespaceImport__Group_2__0 ) )
            {
            // InternalSolverLanguageParser.g:3188:1: ( ( rule__NamespaceImport__Group_2__0 ) )
            // InternalSolverLanguageParser.g:3189:2: ( rule__NamespaceImport__Group_2__0 )
            {
             before(grammarAccess.getNamespaceImportAccess().getGroup_2()); 
            // InternalSolverLanguageParser.g:3190:2: ( rule__NamespaceImport__Group_2__0 )
            // InternalSolverLanguageParser.g:3190:3: rule__NamespaceImport__Group_2__0
            {
            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group_2__0();

            state._fsp--;


            }

             after(grammarAccess.getNamespaceImportAccess().getGroup_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__3"
    // InternalSolverLanguageParser.g:3198:1: rule__NamespaceImport__Group__3 : rule__NamespaceImport__Group__3__Impl ;
    public final void rule__NamespaceImport__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3202:1: ( rule__NamespaceImport__Group__3__Impl )
            // InternalSolverLanguageParser.g:3203:2: rule__NamespaceImport__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group__3__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group__3__Impl"
    // InternalSolverLanguageParser.g:3209:1: rule__NamespaceImport__Group__3__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__NamespaceImport__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3213:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:3214:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:3214:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:3215:2: RULE_FULL_STOP
            {
             before(grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group_2__0"
    // InternalSolverLanguageParser.g:3225:1: rule__NamespaceImport__Group_2__0 : rule__NamespaceImport__Group_2__0__Impl rule__NamespaceImport__Group_2__1 ;
    public final void rule__NamespaceImport__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3229:1: ( rule__NamespaceImport__Group_2__0__Impl rule__NamespaceImport__Group_2__1 )
            // InternalSolverLanguageParser.g:3230:2: rule__NamespaceImport__Group_2__0__Impl rule__NamespaceImport__Group_2__1
            {
            pushFollow(FOLLOW_6);
            rule__NamespaceImport__Group_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group_2__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group_2__0__Impl"
    // InternalSolverLanguageParser.g:3237:1: rule__NamespaceImport__Group_2__0__Impl : ( As ) ;
    public final void rule__NamespaceImport__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3241:1: ( ( As ) )
            // InternalSolverLanguageParser.g:3242:1: ( As )
            {
            // InternalSolverLanguageParser.g:3242:1: ( As )
            // InternalSolverLanguageParser.g:3243:2: As
            {
             before(grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); 
            match(input,As,FOLLOW_2); 
             after(grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group_2__1"
    // InternalSolverLanguageParser.g:3252:1: rule__NamespaceImport__Group_2__1 : rule__NamespaceImport__Group_2__1__Impl ;
    public final void rule__NamespaceImport__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3256:1: ( rule__NamespaceImport__Group_2__1__Impl )
            // InternalSolverLanguageParser.g:3257:2: rule__NamespaceImport__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NamespaceImport__Group_2__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NamespaceImport__Group_2__1__Impl"
    // InternalSolverLanguageParser.g:3263:1: rule__NamespaceImport__Group_2__1__Impl : ( ( rule__NamespaceImport__AliasAssignment_2_1 ) ) ;
    public final void rule__NamespaceImport__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3267:1: ( ( ( rule__NamespaceImport__AliasAssignment_2_1 ) ) )
            // InternalSolverLanguageParser.g:3268:1: ( ( rule__NamespaceImport__AliasAssignment_2_1 ) )
            {
            // InternalSolverLanguageParser.g:3268:1: ( ( rule__NamespaceImport__AliasAssignment_2_1 ) )
            // InternalSolverLanguageParser.g:3269:2: ( rule__NamespaceImport__AliasAssignment_2_1 )
            {
             before(grammarAccess.getNamespaceImportAccess().getAliasAssignment_2_1()); 
            // InternalSolverLanguageParser.g:3270:2: ( rule__NamespaceImport__AliasAssignment_2_1 )
            // InternalSolverLanguageParser.g:3270:3: rule__NamespaceImport__AliasAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__NamespaceImport__AliasAssignment_2_1();

            state._fsp--;


            }

             after(grammarAccess.getNamespaceImportAccess().getAliasAssignment_2_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group__0"
    // InternalSolverLanguageParser.g:3279:1: rule__AssertionOrDefinition__Group__0 : rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 ;
    public final void rule__AssertionOrDefinition__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3283:1: ( rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 )
            // InternalSolverLanguageParser.g:3284:2: rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1
            {
            pushFollow(FOLLOW_10);
            rule__AssertionOrDefinition__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group__0__Impl"
    // InternalSolverLanguageParser.g:3291:1: rule__AssertionOrDefinition__Group__0__Impl : ( ruleExpression ) ;
    public final void rule__AssertionOrDefinition__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3295:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:3296:1: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:3296:1: ( ruleExpression )
            // InternalSolverLanguageParser.g:3297:2: ruleExpression
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group__1"
    // InternalSolverLanguageParser.g:3306:1: rule__AssertionOrDefinition__Group__1 : rule__AssertionOrDefinition__Group__1__Impl rule__AssertionOrDefinition__Group__2 ;
    public final void rule__AssertionOrDefinition__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3310:1: ( rule__AssertionOrDefinition__Group__1__Impl rule__AssertionOrDefinition__Group__2 )
            // InternalSolverLanguageParser.g:3311:2: rule__AssertionOrDefinition__Group__1__Impl rule__AssertionOrDefinition__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__AssertionOrDefinition__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group__1__Impl"
    // InternalSolverLanguageParser.g:3318:1: rule__AssertionOrDefinition__Group__1__Impl : ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) ;
    public final void rule__AssertionOrDefinition__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3322:1: ( ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) )
            // InternalSolverLanguageParser.g:3323:1: ( ( rule__AssertionOrDefinition__Alternatives_1 ) )
            {
            // InternalSolverLanguageParser.g:3323:1: ( ( rule__AssertionOrDefinition__Alternatives_1 ) )
            // InternalSolverLanguageParser.g:3324:2: ( rule__AssertionOrDefinition__Alternatives_1 )
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); 
            // InternalSolverLanguageParser.g:3325:2: ( rule__AssertionOrDefinition__Alternatives_1 )
            // InternalSolverLanguageParser.g:3325:3: rule__AssertionOrDefinition__Alternatives_1
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Alternatives_1();

            state._fsp--;


            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group__2"
    // InternalSolverLanguageParser.g:3333:1: rule__AssertionOrDefinition__Group__2 : rule__AssertionOrDefinition__Group__2__Impl ;
    public final void rule__AssertionOrDefinition__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3337:1: ( rule__AssertionOrDefinition__Group__2__Impl )
            // InternalSolverLanguageParser.g:3338:2: rule__AssertionOrDefinition__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group__2__Impl"
    // InternalSolverLanguageParser.g:3344:1: rule__AssertionOrDefinition__Group__2__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__AssertionOrDefinition__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3348:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:3349:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:3349:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:3350:2: RULE_FULL_STOP
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__0"
    // InternalSolverLanguageParser.g:3360:1: rule__AssertionOrDefinition__Group_1_0__0 : rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 ;
    public final void rule__AssertionOrDefinition__Group_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3364:1: ( rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 )
            // InternalSolverLanguageParser.g:3365:2: rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1
            {
            pushFollow(FOLLOW_11);
            rule__AssertionOrDefinition__Group_1_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_0__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__0__Impl"
    // InternalSolverLanguageParser.g:3372:1: rule__AssertionOrDefinition__Group_1_0__0__Impl : ( () ) ;
    public final void rule__AssertionOrDefinition__Group_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3376:1: ( ( () ) )
            // InternalSolverLanguageParser.g:3377:1: ( () )
            {
            // InternalSolverLanguageParser.g:3377:1: ( () )
            // InternalSolverLanguageParser.g:3378:2: ()
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0()); 
            // InternalSolverLanguageParser.g:3379:2: ()
            // InternalSolverLanguageParser.g:3379:3: 
            {
            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__1"
    // InternalSolverLanguageParser.g:3387:1: rule__AssertionOrDefinition__Group_1_0__1 : rule__AssertionOrDefinition__Group_1_0__1__Impl ;
    public final void rule__AssertionOrDefinition__Group_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3391:1: ( rule__AssertionOrDefinition__Group_1_0__1__Impl )
            // InternalSolverLanguageParser.g:3392:2: rule__AssertionOrDefinition__Group_1_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_0__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__1__Impl"
    // InternalSolverLanguageParser.g:3398:1: rule__AssertionOrDefinition__Group_1_0__1__Impl : ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) ;
    public final void rule__AssertionOrDefinition__Group_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3402:1: ( ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) )
            // InternalSolverLanguageParser.g:3403:1: ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? )
            {
            // InternalSolverLanguageParser.g:3403:1: ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? )
            // InternalSolverLanguageParser.g:3404:2: ( rule__AssertionOrDefinition__Group_1_0_1__0 )?
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); 
            // InternalSolverLanguageParser.g:3405:2: ( rule__AssertionOrDefinition__Group_1_0_1__0 )?
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==Colon) ) {
                alt33=1;
            }
            switch (alt33) {
                case 1 :
                    // InternalSolverLanguageParser.g:3405:3: rule__AssertionOrDefinition__Group_1_0_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__AssertionOrDefinition__Group_1_0_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__0"
    // InternalSolverLanguageParser.g:3414:1: rule__AssertionOrDefinition__Group_1_0_1__0 : rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 ;
    public final void rule__AssertionOrDefinition__Group_1_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3418:1: ( rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 )
            // InternalSolverLanguageParser.g:3419:2: rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1
            {
            pushFollow(FOLLOW_12);
            rule__AssertionOrDefinition__Group_1_0_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_0_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__0__Impl"
    // InternalSolverLanguageParser.g:3426:1: rule__AssertionOrDefinition__Group_1_0_1__0__Impl : ( Colon ) ;
    public final void rule__AssertionOrDefinition__Group_1_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3430:1: ( ( Colon ) )
            // InternalSolverLanguageParser.g:3431:1: ( Colon )
            {
            // InternalSolverLanguageParser.g:3431:1: ( Colon )
            // InternalSolverLanguageParser.g:3432:2: Colon
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); 
            match(input,Colon,FOLLOW_2); 
             after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__1"
    // InternalSolverLanguageParser.g:3441:1: rule__AssertionOrDefinition__Group_1_0_1__1 : rule__AssertionOrDefinition__Group_1_0_1__1__Impl ;
    public final void rule__AssertionOrDefinition__Group_1_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3445:1: ( rule__AssertionOrDefinition__Group_1_0_1__1__Impl )
            // InternalSolverLanguageParser.g:3446:2: rule__AssertionOrDefinition__Group_1_0_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_0_1__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__1__Impl"
    // InternalSolverLanguageParser.g:3452:1: rule__AssertionOrDefinition__Group_1_0_1__1__Impl : ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) ;
    public final void rule__AssertionOrDefinition__Group_1_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3456:1: ( ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) )
            // InternalSolverLanguageParser.g:3457:1: ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) )
            {
            // InternalSolverLanguageParser.g:3457:1: ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) )
            // InternalSolverLanguageParser.g:3458:2: ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 )
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); 
            // InternalSolverLanguageParser.g:3459:2: ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 )
            // InternalSolverLanguageParser.g:3459:3: rule__AssertionOrDefinition__RangeAssignment_1_0_1_1
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__RangeAssignment_1_0_1_1();

            state._fsp--;


            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__0"
    // InternalSolverLanguageParser.g:3468:1: rule__AssertionOrDefinition__Group_1_1__0 : rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 ;
    public final void rule__AssertionOrDefinition__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3472:1: ( rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 )
            // InternalSolverLanguageParser.g:3473:2: rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1
            {
            pushFollow(FOLLOW_13);
            rule__AssertionOrDefinition__Group_1_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__0__Impl"
    // InternalSolverLanguageParser.g:3480:1: rule__AssertionOrDefinition__Group_1_1__0__Impl : ( () ) ;
    public final void rule__AssertionOrDefinition__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3484:1: ( ( () ) )
            // InternalSolverLanguageParser.g:3485:1: ( () )
            {
            // InternalSolverLanguageParser.g:3485:1: ( () )
            // InternalSolverLanguageParser.g:3486:2: ()
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); 
            // InternalSolverLanguageParser.g:3487:2: ()
            // InternalSolverLanguageParser.g:3487:3: 
            {
            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__1"
    // InternalSolverLanguageParser.g:3495:1: rule__AssertionOrDefinition__Group_1_1__1 : rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 ;
    public final void rule__AssertionOrDefinition__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3499:1: ( rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 )
            // InternalSolverLanguageParser.g:3500:2: rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2
            {
            pushFollow(FOLLOW_12);
            rule__AssertionOrDefinition__Group_1_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_1__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__1__Impl"
    // InternalSolverLanguageParser.g:3507:1: rule__AssertionOrDefinition__Group_1_1__1__Impl : ( ColonHyphenMinus ) ;
    public final void rule__AssertionOrDefinition__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3511:1: ( ( ColonHyphenMinus ) )
            // InternalSolverLanguageParser.g:3512:1: ( ColonHyphenMinus )
            {
            // InternalSolverLanguageParser.g:3512:1: ( ColonHyphenMinus )
            // InternalSolverLanguageParser.g:3513:2: ColonHyphenMinus
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); 
            match(input,ColonHyphenMinus,FOLLOW_2); 
             after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__2"
    // InternalSolverLanguageParser.g:3522:1: rule__AssertionOrDefinition__Group_1_1__2 : rule__AssertionOrDefinition__Group_1_1__2__Impl ;
    public final void rule__AssertionOrDefinition__Group_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3526:1: ( rule__AssertionOrDefinition__Group_1_1__2__Impl )
            // InternalSolverLanguageParser.g:3527:2: rule__AssertionOrDefinition__Group_1_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_1__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__2__Impl"
    // InternalSolverLanguageParser.g:3533:1: rule__AssertionOrDefinition__Group_1_1__2__Impl : ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) ;
    public final void rule__AssertionOrDefinition__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3537:1: ( ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) )
            // InternalSolverLanguageParser.g:3538:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) )
            {
            // InternalSolverLanguageParser.g:3538:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) )
            // InternalSolverLanguageParser.g:3539:2: ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 )
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); 
            // InternalSolverLanguageParser.g:3540:2: ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 )
            // InternalSolverLanguageParser.g:3540:3: rule__AssertionOrDefinition__BodyAssignment_1_1_2
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__BodyAssignment_1_1_2();

            state._fsp--;


            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__0"
    // InternalSolverLanguageParser.g:3549:1: rule__AssertionOrDefinition__Group_1_2__0 : rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 ;
    public final void rule__AssertionOrDefinition__Group_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3553:1: ( rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 )
            // InternalSolverLanguageParser.g:3554:2: rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1
            {
            pushFollow(FOLLOW_10);
            rule__AssertionOrDefinition__Group_1_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_2__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__0__Impl"
    // InternalSolverLanguageParser.g:3561:1: rule__AssertionOrDefinition__Group_1_2__0__Impl : ( () ) ;
    public final void rule__AssertionOrDefinition__Group_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3565:1: ( ( () ) )
            // InternalSolverLanguageParser.g:3566:1: ( () )
            {
            // InternalSolverLanguageParser.g:3566:1: ( () )
            // InternalSolverLanguageParser.g:3567:2: ()
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0()); 
            // InternalSolverLanguageParser.g:3568:2: ()
            // InternalSolverLanguageParser.g:3568:3: 
            {
            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__1"
    // InternalSolverLanguageParser.g:3576:1: rule__AssertionOrDefinition__Group_1_2__1 : rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 ;
    public final void rule__AssertionOrDefinition__Group_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3580:1: ( rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 )
            // InternalSolverLanguageParser.g:3581:2: rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2
            {
            pushFollow(FOLLOW_12);
            rule__AssertionOrDefinition__Group_1_2__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_2__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__1__Impl"
    // InternalSolverLanguageParser.g:3588:1: rule__AssertionOrDefinition__Group_1_2__1__Impl : ( ColonEqualsSign ) ;
    public final void rule__AssertionOrDefinition__Group_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3592:1: ( ( ColonEqualsSign ) )
            // InternalSolverLanguageParser.g:3593:1: ( ColonEqualsSign )
            {
            // InternalSolverLanguageParser.g:3593:1: ( ColonEqualsSign )
            // InternalSolverLanguageParser.g:3594:2: ColonEqualsSign
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); 
            match(input,ColonEqualsSign,FOLLOW_2); 
             after(grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__2"
    // InternalSolverLanguageParser.g:3603:1: rule__AssertionOrDefinition__Group_1_2__2 : rule__AssertionOrDefinition__Group_1_2__2__Impl ;
    public final void rule__AssertionOrDefinition__Group_1_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3607:1: ( rule__AssertionOrDefinition__Group_1_2__2__Impl )
            // InternalSolverLanguageParser.g:3608:2: rule__AssertionOrDefinition__Group_1_2__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__Group_1_2__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__2__Impl"
    // InternalSolverLanguageParser.g:3614:1: rule__AssertionOrDefinition__Group_1_2__2__Impl : ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) ;
    public final void rule__AssertionOrDefinition__Group_1_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3618:1: ( ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) )
            // InternalSolverLanguageParser.g:3619:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) )
            {
            // InternalSolverLanguageParser.g:3619:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) )
            // InternalSolverLanguageParser.g:3620:2: ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 )
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); 
            // InternalSolverLanguageParser.g:3621:2: ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 )
            // InternalSolverLanguageParser.g:3621:3: rule__AssertionOrDefinition__BodyAssignment_1_2_2
            {
            pushFollow(FOLLOW_2);
            rule__AssertionOrDefinition__BodyAssignment_1_2_2();

            state._fsp--;


            }

             after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__0"
    // InternalSolverLanguageParser.g:3630:1: rule__PredicateDefinition__Group__0 : rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ;
    public final void rule__PredicateDefinition__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3634:1: ( rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 )
            // InternalSolverLanguageParser.g:3635:2: rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__PredicateDefinition__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__0__Impl"
    // InternalSolverLanguageParser.g:3642:1: rule__PredicateDefinition__Group__0__Impl : ( ( rule__PredicateDefinition__Alternatives_0 ) ) ;
    public final void rule__PredicateDefinition__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3646:1: ( ( ( rule__PredicateDefinition__Alternatives_0 ) ) )
            // InternalSolverLanguageParser.g:3647:1: ( ( rule__PredicateDefinition__Alternatives_0 ) )
            {
            // InternalSolverLanguageParser.g:3647:1: ( ( rule__PredicateDefinition__Alternatives_0 ) )
            // InternalSolverLanguageParser.g:3648:2: ( rule__PredicateDefinition__Alternatives_0 )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); 
            // InternalSolverLanguageParser.g:3649:2: ( rule__PredicateDefinition__Alternatives_0 )
            // InternalSolverLanguageParser.g:3649:3: rule__PredicateDefinition__Alternatives_0
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Alternatives_0();

            state._fsp--;


            }

             after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__1"
    // InternalSolverLanguageParser.g:3657:1: rule__PredicateDefinition__Group__1 : rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ;
    public final void rule__PredicateDefinition__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3661:1: ( rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 )
            // InternalSolverLanguageParser.g:3662:2: rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2
            {
            pushFollow(FOLLOW_13);
            rule__PredicateDefinition__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__1__Impl"
    // InternalSolverLanguageParser.g:3669:1: rule__PredicateDefinition__Group__1__Impl : ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) ;
    public final void rule__PredicateDefinition__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3673:1: ( ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:3674:1: ( ( rule__PredicateDefinition__HeadAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:3674:1: ( ( rule__PredicateDefinition__HeadAssignment_1 ) )
            // InternalSolverLanguageParser.g:3675:2: ( rule__PredicateDefinition__HeadAssignment_1 )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); 
            // InternalSolverLanguageParser.g:3676:2: ( rule__PredicateDefinition__HeadAssignment_1 )
            // InternalSolverLanguageParser.g:3676:3: rule__PredicateDefinition__HeadAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__HeadAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__2"
    // InternalSolverLanguageParser.g:3684:1: rule__PredicateDefinition__Group__2 : rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ;
    public final void rule__PredicateDefinition__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3688:1: ( rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 )
            // InternalSolverLanguageParser.g:3689:2: rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3
            {
            pushFollow(FOLLOW_12);
            rule__PredicateDefinition__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__2__Impl"
    // InternalSolverLanguageParser.g:3696:1: rule__PredicateDefinition__Group__2__Impl : ( ColonHyphenMinus ) ;
    public final void rule__PredicateDefinition__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3700:1: ( ( ColonHyphenMinus ) )
            // InternalSolverLanguageParser.g:3701:1: ( ColonHyphenMinus )
            {
            // InternalSolverLanguageParser.g:3701:1: ( ColonHyphenMinus )
            // InternalSolverLanguageParser.g:3702:2: ColonHyphenMinus
            {
             before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); 
            match(input,ColonHyphenMinus,FOLLOW_2); 
             after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__3"
    // InternalSolverLanguageParser.g:3711:1: rule__PredicateDefinition__Group__3 : rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ;
    public final void rule__PredicateDefinition__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3715:1: ( rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 )
            // InternalSolverLanguageParser.g:3716:2: rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__PredicateDefinition__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__3__Impl"
    // InternalSolverLanguageParser.g:3723:1: rule__PredicateDefinition__Group__3__Impl : ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) ;
    public final void rule__PredicateDefinition__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3727:1: ( ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:3728:1: ( ( rule__PredicateDefinition__BodyAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:3728:1: ( ( rule__PredicateDefinition__BodyAssignment_3 ) )
            // InternalSolverLanguageParser.g:3729:2: ( rule__PredicateDefinition__BodyAssignment_3 )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); 
            // InternalSolverLanguageParser.g:3730:2: ( rule__PredicateDefinition__BodyAssignment_3 )
            // InternalSolverLanguageParser.g:3730:3: rule__PredicateDefinition__BodyAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__BodyAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__4"
    // InternalSolverLanguageParser.g:3738:1: rule__PredicateDefinition__Group__4 : rule__PredicateDefinition__Group__4__Impl ;
    public final void rule__PredicateDefinition__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3742:1: ( rule__PredicateDefinition__Group__4__Impl )
            // InternalSolverLanguageParser.g:3743:2: rule__PredicateDefinition__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group__4__Impl"
    // InternalSolverLanguageParser.g:3749:1: rule__PredicateDefinition__Group__4__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__PredicateDefinition__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3753:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:3754:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:3754:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:3755:2: RULE_FULL_STOP
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_0__0"
    // InternalSolverLanguageParser.g:3765:1: rule__PredicateDefinition__Group_0_0__0 : rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ;
    public final void rule__PredicateDefinition__Group_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3769:1: ( rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 )
            // InternalSolverLanguageParser.g:3770:2: rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1
            {
            pushFollow(FOLLOW_14);
            rule__PredicateDefinition__Group_0_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group_0_0__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_0__0__Impl"
    // InternalSolverLanguageParser.g:3777:1: rule__PredicateDefinition__Group_0_0__0__Impl : ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) ;
    public final void rule__PredicateDefinition__Group_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3781:1: ( ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) )
            // InternalSolverLanguageParser.g:3782:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) )
            {
            // InternalSolverLanguageParser.g:3782:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) )
            // InternalSolverLanguageParser.g:3783:2: ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); 
            // InternalSolverLanguageParser.g:3784:2: ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 )
            // InternalSolverLanguageParser.g:3784:3: rule__PredicateDefinition__FunctionalAssignment_0_0_0
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__FunctionalAssignment_0_0_0();

            state._fsp--;


            }

             after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_0__1"
    // InternalSolverLanguageParser.g:3792:1: rule__PredicateDefinition__Group_0_0__1 : rule__PredicateDefinition__Group_0_0__1__Impl ;
    public final void rule__PredicateDefinition__Group_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3796:1: ( rule__PredicateDefinition__Group_0_0__1__Impl )
            // InternalSolverLanguageParser.g:3797:2: rule__PredicateDefinition__Group_0_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group_0_0__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_0__1__Impl"
    // InternalSolverLanguageParser.g:3803:1: rule__PredicateDefinition__Group_0_0__1__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) ;
    public final void rule__PredicateDefinition__Group_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3807:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) )
            // InternalSolverLanguageParser.g:3808:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? )
            {
            // InternalSolverLanguageParser.g:3808:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? )
            // InternalSolverLanguageParser.g:3809:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )?
            {
             before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); 
            // InternalSolverLanguageParser.g:3810:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )?
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==Error) ) {
                alt34=1;
            }
            switch (alt34) {
                case 1 :
                    // InternalSolverLanguageParser.g:3810:3: rule__PredicateDefinition__ErrorAssignment_0_0_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__PredicateDefinition__ErrorAssignment_0_0_1();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_1__0"
    // InternalSolverLanguageParser.g:3819:1: rule__PredicateDefinition__Group_0_1__0 : rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 ;
    public final void rule__PredicateDefinition__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3823:1: ( rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 )
            // InternalSolverLanguageParser.g:3824:2: rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1
            {
            pushFollow(FOLLOW_15);
            rule__PredicateDefinition__Group_0_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group_0_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_1__0__Impl"
    // InternalSolverLanguageParser.g:3831:1: rule__PredicateDefinition__Group_0_1__0__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) ;
    public final void rule__PredicateDefinition__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3835:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) )
            // InternalSolverLanguageParser.g:3836:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) )
            {
            // InternalSolverLanguageParser.g:3836:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) )
            // InternalSolverLanguageParser.g:3837:2: ( rule__PredicateDefinition__ErrorAssignment_0_1_0 )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); 
            // InternalSolverLanguageParser.g:3838:2: ( rule__PredicateDefinition__ErrorAssignment_0_1_0 )
            // InternalSolverLanguageParser.g:3838:3: rule__PredicateDefinition__ErrorAssignment_0_1_0
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__ErrorAssignment_0_1_0();

            state._fsp--;


            }

             after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_1__1"
    // InternalSolverLanguageParser.g:3846:1: rule__PredicateDefinition__Group_0_1__1 : rule__PredicateDefinition__Group_0_1__1__Impl ;
    public final void rule__PredicateDefinition__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3850:1: ( rule__PredicateDefinition__Group_0_1__1__Impl )
            // InternalSolverLanguageParser.g:3851:2: rule__PredicateDefinition__Group_0_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PredicateDefinition__Group_0_1__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PredicateDefinition__Group_0_1__1__Impl"
    // InternalSolverLanguageParser.g:3857:1: rule__PredicateDefinition__Group_0_1__1__Impl : ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) ;
    public final void rule__PredicateDefinition__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3861:1: ( ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) )
            // InternalSolverLanguageParser.g:3862:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? )
            {
            // InternalSolverLanguageParser.g:3862:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? )
            // InternalSolverLanguageParser.g:3863:2: ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )?
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); 
            // InternalSolverLanguageParser.g:3864:2: ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )?
            int alt35=2;
            int LA35_0 = input.LA(1);

            if ( (LA35_0==Functional) ) {
                alt35=1;
            }
            switch (alt35) {
                case 1 :
                    // InternalSolverLanguageParser.g:3864:3: rule__PredicateDefinition__FunctionalAssignment_0_1_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__PredicateDefinition__FunctionalAssignment_0_1_1();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__0"
    // InternalSolverLanguageParser.g:3873:1: rule__UnnamedErrorPredicateDefintion__Group__0 : rule__UnnamedErrorPredicateDefintion__Group__0__Impl rule__UnnamedErrorPredicateDefintion__Group__1 ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3877:1: ( rule__UnnamedErrorPredicateDefintion__Group__0__Impl rule__UnnamedErrorPredicateDefintion__Group__1 )
            // InternalSolverLanguageParser.g:3878:2: rule__UnnamedErrorPredicateDefintion__Group__0__Impl rule__UnnamedErrorPredicateDefintion__Group__1
            {
            pushFollow(FOLLOW_16);
            rule__UnnamedErrorPredicateDefintion__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__0__Impl"
    // InternalSolverLanguageParser.g:3885:1: rule__UnnamedErrorPredicateDefintion__Group__0__Impl : ( Error ) ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3889:1: ( ( Error ) )
            // InternalSolverLanguageParser.g:3890:1: ( Error )
            {
            // InternalSolverLanguageParser.g:3890:1: ( Error )
            // InternalSolverLanguageParser.g:3891:2: Error
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); 
            match(input,Error,FOLLOW_2); 
             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__1"
    // InternalSolverLanguageParser.g:3900:1: rule__UnnamedErrorPredicateDefintion__Group__1 : rule__UnnamedErrorPredicateDefintion__Group__1__Impl rule__UnnamedErrorPredicateDefintion__Group__2 ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3904:1: ( rule__UnnamedErrorPredicateDefintion__Group__1__Impl rule__UnnamedErrorPredicateDefintion__Group__2 )
            // InternalSolverLanguageParser.g:3905:2: rule__UnnamedErrorPredicateDefintion__Group__1__Impl rule__UnnamedErrorPredicateDefintion__Group__2
            {
            pushFollow(FOLLOW_13);
            rule__UnnamedErrorPredicateDefintion__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__1__Impl"
    // InternalSolverLanguageParser.g:3912:1: rule__UnnamedErrorPredicateDefintion__Group__1__Impl : ( ( rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 ) ) ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3916:1: ( ( ( rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:3917:1: ( ( rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:3917:1: ( ( rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 ) )
            // InternalSolverLanguageParser.g:3918:2: ( rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 )
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListAssignment_1()); 
            // InternalSolverLanguageParser.g:3919:2: ( rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 )
            // InternalSolverLanguageParser.g:3919:3: rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__2"
    // InternalSolverLanguageParser.g:3927:1: rule__UnnamedErrorPredicateDefintion__Group__2 : rule__UnnamedErrorPredicateDefintion__Group__2__Impl rule__UnnamedErrorPredicateDefintion__Group__3 ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3931:1: ( rule__UnnamedErrorPredicateDefintion__Group__2__Impl rule__UnnamedErrorPredicateDefintion__Group__3 )
            // InternalSolverLanguageParser.g:3932:2: rule__UnnamedErrorPredicateDefintion__Group__2__Impl rule__UnnamedErrorPredicateDefintion__Group__3
            {
            pushFollow(FOLLOW_12);
            rule__UnnamedErrorPredicateDefintion__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__2__Impl"
    // InternalSolverLanguageParser.g:3939:1: rule__UnnamedErrorPredicateDefintion__Group__2__Impl : ( ColonHyphenMinus ) ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3943:1: ( ( ColonHyphenMinus ) )
            // InternalSolverLanguageParser.g:3944:1: ( ColonHyphenMinus )
            {
            // InternalSolverLanguageParser.g:3944:1: ( ColonHyphenMinus )
            // InternalSolverLanguageParser.g:3945:2: ColonHyphenMinus
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); 
            match(input,ColonHyphenMinus,FOLLOW_2); 
             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__3"
    // InternalSolverLanguageParser.g:3954:1: rule__UnnamedErrorPredicateDefintion__Group__3 : rule__UnnamedErrorPredicateDefintion__Group__3__Impl rule__UnnamedErrorPredicateDefintion__Group__4 ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3958:1: ( rule__UnnamedErrorPredicateDefintion__Group__3__Impl rule__UnnamedErrorPredicateDefintion__Group__4 )
            // InternalSolverLanguageParser.g:3959:2: rule__UnnamedErrorPredicateDefintion__Group__3__Impl rule__UnnamedErrorPredicateDefintion__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__UnnamedErrorPredicateDefintion__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__3__Impl"
    // InternalSolverLanguageParser.g:3966:1: rule__UnnamedErrorPredicateDefintion__Group__3__Impl : ( ( rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 ) ) ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3970:1: ( ( ( rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:3971:1: ( ( rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:3971:1: ( ( rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 ) )
            // InternalSolverLanguageParser.g:3972:2: ( rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 )
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyAssignment_3()); 
            // InternalSolverLanguageParser.g:3973:2: ( rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 )
            // InternalSolverLanguageParser.g:3973:3: rule__UnnamedErrorPredicateDefintion__BodyAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__BodyAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__4"
    // InternalSolverLanguageParser.g:3981:1: rule__UnnamedErrorPredicateDefintion__Group__4 : rule__UnnamedErrorPredicateDefintion__Group__4__Impl ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3985:1: ( rule__UnnamedErrorPredicateDefintion__Group__4__Impl )
            // InternalSolverLanguageParser.g:3986:2: rule__UnnamedErrorPredicateDefintion__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UnnamedErrorPredicateDefintion__Group__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__Group__4__Impl"
    // InternalSolverLanguageParser.g:3992:1: rule__UnnamedErrorPredicateDefintion__Group__4__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__UnnamedErrorPredicateDefintion__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:3996:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:3997:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:3997:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:3998:2: RULE_FULL_STOP
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__0"
    // InternalSolverLanguageParser.g:4008:1: rule__DefaultAssertion__Group__0 : rule__DefaultAssertion__Group__0__Impl rule__DefaultAssertion__Group__1 ;
    public final void rule__DefaultAssertion__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4012:1: ( rule__DefaultAssertion__Group__0__Impl rule__DefaultAssertion__Group__1 )
            // InternalSolverLanguageParser.g:4013:2: rule__DefaultAssertion__Group__0__Impl rule__DefaultAssertion__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__DefaultAssertion__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__0__Impl"
    // InternalSolverLanguageParser.g:4020:1: rule__DefaultAssertion__Group__0__Impl : ( Default ) ;
    public final void rule__DefaultAssertion__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4024:1: ( ( Default ) )
            // InternalSolverLanguageParser.g:4025:1: ( Default )
            {
            // InternalSolverLanguageParser.g:4025:1: ( Default )
            // InternalSolverLanguageParser.g:4026:2: Default
            {
             before(grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); 
            match(input,Default,FOLLOW_2); 
             after(grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__1"
    // InternalSolverLanguageParser.g:4035:1: rule__DefaultAssertion__Group__1 : rule__DefaultAssertion__Group__1__Impl rule__DefaultAssertion__Group__2 ;
    public final void rule__DefaultAssertion__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4039:1: ( rule__DefaultAssertion__Group__1__Impl rule__DefaultAssertion__Group__2 )
            // InternalSolverLanguageParser.g:4040:2: rule__DefaultAssertion__Group__1__Impl rule__DefaultAssertion__Group__2
            {
            pushFollow(FOLLOW_17);
            rule__DefaultAssertion__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__1__Impl"
    // InternalSolverLanguageParser.g:4047:1: rule__DefaultAssertion__Group__1__Impl : ( ( rule__DefaultAssertion__ExpressionAssignment_1 ) ) ;
    public final void rule__DefaultAssertion__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4051:1: ( ( ( rule__DefaultAssertion__ExpressionAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:4052:1: ( ( rule__DefaultAssertion__ExpressionAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:4052:1: ( ( rule__DefaultAssertion__ExpressionAssignment_1 ) )
            // InternalSolverLanguageParser.g:4053:2: ( rule__DefaultAssertion__ExpressionAssignment_1 )
            {
             before(grammarAccess.getDefaultAssertionAccess().getExpressionAssignment_1()); 
            // InternalSolverLanguageParser.g:4054:2: ( rule__DefaultAssertion__ExpressionAssignment_1 )
            // InternalSolverLanguageParser.g:4054:3: rule__DefaultAssertion__ExpressionAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__ExpressionAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getDefaultAssertionAccess().getExpressionAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__2"
    // InternalSolverLanguageParser.g:4062:1: rule__DefaultAssertion__Group__2 : rule__DefaultAssertion__Group__2__Impl rule__DefaultAssertion__Group__3 ;
    public final void rule__DefaultAssertion__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4066:1: ( rule__DefaultAssertion__Group__2__Impl rule__DefaultAssertion__Group__3 )
            // InternalSolverLanguageParser.g:4067:2: rule__DefaultAssertion__Group__2__Impl rule__DefaultAssertion__Group__3
            {
            pushFollow(FOLLOW_17);
            rule__DefaultAssertion__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__2__Impl"
    // InternalSolverLanguageParser.g:4074:1: rule__DefaultAssertion__Group__2__Impl : ( ( rule__DefaultAssertion__Group_2__0 )? ) ;
    public final void rule__DefaultAssertion__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4078:1: ( ( ( rule__DefaultAssertion__Group_2__0 )? ) )
            // InternalSolverLanguageParser.g:4079:1: ( ( rule__DefaultAssertion__Group_2__0 )? )
            {
            // InternalSolverLanguageParser.g:4079:1: ( ( rule__DefaultAssertion__Group_2__0 )? )
            // InternalSolverLanguageParser.g:4080:2: ( rule__DefaultAssertion__Group_2__0 )?
            {
             before(grammarAccess.getDefaultAssertionAccess().getGroup_2()); 
            // InternalSolverLanguageParser.g:4081:2: ( rule__DefaultAssertion__Group_2__0 )?
            int alt36=2;
            int LA36_0 = input.LA(1);

            if ( (LA36_0==Colon) ) {
                alt36=1;
            }
            switch (alt36) {
                case 1 :
                    // InternalSolverLanguageParser.g:4081:3: rule__DefaultAssertion__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__DefaultAssertion__Group_2__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getDefaultAssertionAccess().getGroup_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__3"
    // InternalSolverLanguageParser.g:4089:1: rule__DefaultAssertion__Group__3 : rule__DefaultAssertion__Group__3__Impl ;
    public final void rule__DefaultAssertion__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4093:1: ( rule__DefaultAssertion__Group__3__Impl )
            // InternalSolverLanguageParser.g:4094:2: rule__DefaultAssertion__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group__3__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group__3__Impl"
    // InternalSolverLanguageParser.g:4100:1: rule__DefaultAssertion__Group__3__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__DefaultAssertion__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4104:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:4105:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:4105:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:4106:2: RULE_FULL_STOP
            {
             before(grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group_2__0"
    // InternalSolverLanguageParser.g:4116:1: rule__DefaultAssertion__Group_2__0 : rule__DefaultAssertion__Group_2__0__Impl rule__DefaultAssertion__Group_2__1 ;
    public final void rule__DefaultAssertion__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4120:1: ( rule__DefaultAssertion__Group_2__0__Impl rule__DefaultAssertion__Group_2__1 )
            // InternalSolverLanguageParser.g:4121:2: rule__DefaultAssertion__Group_2__0__Impl rule__DefaultAssertion__Group_2__1
            {
            pushFollow(FOLLOW_12);
            rule__DefaultAssertion__Group_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group_2__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group_2__0__Impl"
    // InternalSolverLanguageParser.g:4128:1: rule__DefaultAssertion__Group_2__0__Impl : ( Colon ) ;
    public final void rule__DefaultAssertion__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4132:1: ( ( Colon ) )
            // InternalSolverLanguageParser.g:4133:1: ( Colon )
            {
            // InternalSolverLanguageParser.g:4133:1: ( Colon )
            // InternalSolverLanguageParser.g:4134:2: Colon
            {
             before(grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); 
            match(input,Colon,FOLLOW_2); 
             after(grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group_2__1"
    // InternalSolverLanguageParser.g:4143:1: rule__DefaultAssertion__Group_2__1 : rule__DefaultAssertion__Group_2__1__Impl ;
    public final void rule__DefaultAssertion__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4147:1: ( rule__DefaultAssertion__Group_2__1__Impl )
            // InternalSolverLanguageParser.g:4148:2: rule__DefaultAssertion__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__Group_2__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DefaultAssertion__Group_2__1__Impl"
    // InternalSolverLanguageParser.g:4154:1: rule__DefaultAssertion__Group_2__1__Impl : ( ( rule__DefaultAssertion__RangeAssignment_2_1 ) ) ;
    public final void rule__DefaultAssertion__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4158:1: ( ( ( rule__DefaultAssertion__RangeAssignment_2_1 ) ) )
            // InternalSolverLanguageParser.g:4159:1: ( ( rule__DefaultAssertion__RangeAssignment_2_1 ) )
            {
            // InternalSolverLanguageParser.g:4159:1: ( ( rule__DefaultAssertion__RangeAssignment_2_1 ) )
            // InternalSolverLanguageParser.g:4160:2: ( rule__DefaultAssertion__RangeAssignment_2_1 )
            {
             before(grammarAccess.getDefaultAssertionAccess().getRangeAssignment_2_1()); 
            // InternalSolverLanguageParser.g:4161:2: ( rule__DefaultAssertion__RangeAssignment_2_1 )
            // InternalSolverLanguageParser.g:4161:3: rule__DefaultAssertion__RangeAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__DefaultAssertion__RangeAssignment_2_1();

            state._fsp--;


            }

             after(grammarAccess.getDefaultAssertionAccess().getRangeAssignment_2_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__0"
    // InternalSolverLanguageParser.g:4170:1: rule__FunctionDefinition__Group__0 : rule__FunctionDefinition__Group__0__Impl rule__FunctionDefinition__Group__1 ;
    public final void rule__FunctionDefinition__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4174:1: ( rule__FunctionDefinition__Group__0__Impl rule__FunctionDefinition__Group__1 )
            // InternalSolverLanguageParser.g:4175:2: rule__FunctionDefinition__Group__0__Impl rule__FunctionDefinition__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__FunctionDefinition__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__0__Impl"
    // InternalSolverLanguageParser.g:4182:1: rule__FunctionDefinition__Group__0__Impl : ( ( rule__FunctionDefinition__ResultTypeAssignment_0 ) ) ;
    public final void rule__FunctionDefinition__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4186:1: ( ( ( rule__FunctionDefinition__ResultTypeAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:4187:1: ( ( rule__FunctionDefinition__ResultTypeAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:4187:1: ( ( rule__FunctionDefinition__ResultTypeAssignment_0 ) )
            // InternalSolverLanguageParser.g:4188:2: ( rule__FunctionDefinition__ResultTypeAssignment_0 )
            {
             before(grammarAccess.getFunctionDefinitionAccess().getResultTypeAssignment_0()); 
            // InternalSolverLanguageParser.g:4189:2: ( rule__FunctionDefinition__ResultTypeAssignment_0 )
            // InternalSolverLanguageParser.g:4189:3: rule__FunctionDefinition__ResultTypeAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__ResultTypeAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getFunctionDefinitionAccess().getResultTypeAssignment_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__1"
    // InternalSolverLanguageParser.g:4197:1: rule__FunctionDefinition__Group__1 : rule__FunctionDefinition__Group__1__Impl rule__FunctionDefinition__Group__2 ;
    public final void rule__FunctionDefinition__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4201:1: ( rule__FunctionDefinition__Group__1__Impl rule__FunctionDefinition__Group__2 )
            // InternalSolverLanguageParser.g:4202:2: rule__FunctionDefinition__Group__1__Impl rule__FunctionDefinition__Group__2
            {
            pushFollow(FOLLOW_18);
            rule__FunctionDefinition__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__1__Impl"
    // InternalSolverLanguageParser.g:4209:1: rule__FunctionDefinition__Group__1__Impl : ( ( rule__FunctionDefinition__HeadAssignment_1 ) ) ;
    public final void rule__FunctionDefinition__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4213:1: ( ( ( rule__FunctionDefinition__HeadAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:4214:1: ( ( rule__FunctionDefinition__HeadAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:4214:1: ( ( rule__FunctionDefinition__HeadAssignment_1 ) )
            // InternalSolverLanguageParser.g:4215:2: ( rule__FunctionDefinition__HeadAssignment_1 )
            {
             before(grammarAccess.getFunctionDefinitionAccess().getHeadAssignment_1()); 
            // InternalSolverLanguageParser.g:4216:2: ( rule__FunctionDefinition__HeadAssignment_1 )
            // InternalSolverLanguageParser.g:4216:3: rule__FunctionDefinition__HeadAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__HeadAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getFunctionDefinitionAccess().getHeadAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__2"
    // InternalSolverLanguageParser.g:4224:1: rule__FunctionDefinition__Group__2 : rule__FunctionDefinition__Group__2__Impl rule__FunctionDefinition__Group__3 ;
    public final void rule__FunctionDefinition__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4228:1: ( rule__FunctionDefinition__Group__2__Impl rule__FunctionDefinition__Group__3 )
            // InternalSolverLanguageParser.g:4229:2: rule__FunctionDefinition__Group__2__Impl rule__FunctionDefinition__Group__3
            {
            pushFollow(FOLLOW_12);
            rule__FunctionDefinition__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__2__Impl"
    // InternalSolverLanguageParser.g:4236:1: rule__FunctionDefinition__Group__2__Impl : ( ColonEqualsSign ) ;
    public final void rule__FunctionDefinition__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4240:1: ( ( ColonEqualsSign ) )
            // InternalSolverLanguageParser.g:4241:1: ( ColonEqualsSign )
            {
            // InternalSolverLanguageParser.g:4241:1: ( ColonEqualsSign )
            // InternalSolverLanguageParser.g:4242:2: ColonEqualsSign
            {
             before(grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); 
            match(input,ColonEqualsSign,FOLLOW_2); 
             after(grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__3"
    // InternalSolverLanguageParser.g:4251:1: rule__FunctionDefinition__Group__3 : rule__FunctionDefinition__Group__3__Impl rule__FunctionDefinition__Group__4 ;
    public final void rule__FunctionDefinition__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4255:1: ( rule__FunctionDefinition__Group__3__Impl rule__FunctionDefinition__Group__4 )
            // InternalSolverLanguageParser.g:4256:2: rule__FunctionDefinition__Group__3__Impl rule__FunctionDefinition__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__FunctionDefinition__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__3__Impl"
    // InternalSolverLanguageParser.g:4263:1: rule__FunctionDefinition__Group__3__Impl : ( ( rule__FunctionDefinition__BodyAssignment_3 ) ) ;
    public final void rule__FunctionDefinition__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4267:1: ( ( ( rule__FunctionDefinition__BodyAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:4268:1: ( ( rule__FunctionDefinition__BodyAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:4268:1: ( ( rule__FunctionDefinition__BodyAssignment_3 ) )
            // InternalSolverLanguageParser.g:4269:2: ( rule__FunctionDefinition__BodyAssignment_3 )
            {
             before(grammarAccess.getFunctionDefinitionAccess().getBodyAssignment_3()); 
            // InternalSolverLanguageParser.g:4270:2: ( rule__FunctionDefinition__BodyAssignment_3 )
            // InternalSolverLanguageParser.g:4270:3: rule__FunctionDefinition__BodyAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__BodyAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getFunctionDefinitionAccess().getBodyAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__4"
    // InternalSolverLanguageParser.g:4278:1: rule__FunctionDefinition__Group__4 : rule__FunctionDefinition__Group__4__Impl ;
    public final void rule__FunctionDefinition__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4282:1: ( rule__FunctionDefinition__Group__4__Impl )
            // InternalSolverLanguageParser.g:4283:2: rule__FunctionDefinition__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__FunctionDefinition__Group__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__FunctionDefinition__Group__4__Impl"
    // InternalSolverLanguageParser.g:4289:1: rule__FunctionDefinition__Group__4__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__FunctionDefinition__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4293:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:4294:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:4294:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:4295:2: RULE_FULL_STOP
            {
             before(grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__TypeReference__Group__0"
    // InternalSolverLanguageParser.g:4305:1: rule__TypeReference__Group__0 : rule__TypeReference__Group__0__Impl rule__TypeReference__Group__1 ;
    public final void rule__TypeReference__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4309:1: ( rule__TypeReference__Group__0__Impl rule__TypeReference__Group__1 )
            // InternalSolverLanguageParser.g:4310:2: rule__TypeReference__Group__0__Impl rule__TypeReference__Group__1
            {
            pushFollow(FOLLOW_19);
            rule__TypeReference__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__TypeReference__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__TypeReference__Group__0__Impl"
    // InternalSolverLanguageParser.g:4317:1: rule__TypeReference__Group__0__Impl : ( ( rule__TypeReference__TypeAssignment_0 ) ) ;
    public final void rule__TypeReference__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4321:1: ( ( ( rule__TypeReference__TypeAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:4322:1: ( ( rule__TypeReference__TypeAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:4322:1: ( ( rule__TypeReference__TypeAssignment_0 ) )
            // InternalSolverLanguageParser.g:4323:2: ( rule__TypeReference__TypeAssignment_0 )
            {
             before(grammarAccess.getTypeReferenceAccess().getTypeAssignment_0()); 
            // InternalSolverLanguageParser.g:4324:2: ( rule__TypeReference__TypeAssignment_0 )
            // InternalSolverLanguageParser.g:4324:3: rule__TypeReference__TypeAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__TypeReference__TypeAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getTypeReferenceAccess().getTypeAssignment_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__TypeReference__Group__1"
    // InternalSolverLanguageParser.g:4332:1: rule__TypeReference__Group__1 : rule__TypeReference__Group__1__Impl ;
    public final void rule__TypeReference__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4336:1: ( rule__TypeReference__Group__1__Impl )
            // InternalSolverLanguageParser.g:4337:2: rule__TypeReference__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__TypeReference__Group__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__TypeReference__Group__1__Impl"
    // InternalSolverLanguageParser.g:4343:1: rule__TypeReference__Group__1__Impl : ( ( rule__TypeReference__ForceObjectTypeAssignment_1 )? ) ;
    public final void rule__TypeReference__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4347:1: ( ( ( rule__TypeReference__ForceObjectTypeAssignment_1 )? ) )
            // InternalSolverLanguageParser.g:4348:1: ( ( rule__TypeReference__ForceObjectTypeAssignment_1 )? )
            {
            // InternalSolverLanguageParser.g:4348:1: ( ( rule__TypeReference__ForceObjectTypeAssignment_1 )? )
            // InternalSolverLanguageParser.g:4349:2: ( rule__TypeReference__ForceObjectTypeAssignment_1 )?
            {
             before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeAssignment_1()); 
            // InternalSolverLanguageParser.g:4350:2: ( rule__TypeReference__ForceObjectTypeAssignment_1 )?
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( (LA37_0==Object) ) {
                alt37=1;
            }
            switch (alt37) {
                case 1 :
                    // InternalSolverLanguageParser.g:4350:3: rule__TypeReference__ForceObjectTypeAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__TypeReference__ForceObjectTypeAssignment_1();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Attribute__Group__0"
    // InternalSolverLanguageParser.g:4359:1: rule__Attribute__Group__0 : rule__Attribute__Group__0__Impl rule__Attribute__Group__1 ;
    public final void rule__Attribute__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4363:1: ( rule__Attribute__Group__0__Impl rule__Attribute__Group__1 )
            // InternalSolverLanguageParser.g:4364:2: rule__Attribute__Group__0__Impl rule__Attribute__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__Attribute__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Attribute__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Attribute__Group__0__Impl"
    // InternalSolverLanguageParser.g:4371:1: rule__Attribute__Group__0__Impl : ( ( rule__Attribute__KindAssignment_0 ) ) ;
    public final void rule__Attribute__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4375:1: ( ( ( rule__Attribute__KindAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:4376:1: ( ( rule__Attribute__KindAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:4376:1: ( ( rule__Attribute__KindAssignment_0 ) )
            // InternalSolverLanguageParser.g:4377:2: ( rule__Attribute__KindAssignment_0 )
            {
             before(grammarAccess.getAttributeAccess().getKindAssignment_0()); 
            // InternalSolverLanguageParser.g:4378:2: ( rule__Attribute__KindAssignment_0 )
            // InternalSolverLanguageParser.g:4378:3: rule__Attribute__KindAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__Attribute__KindAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getAttributeAccess().getKindAssignment_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Attribute__Group__1"
    // InternalSolverLanguageParser.g:4386:1: rule__Attribute__Group__1 : rule__Attribute__Group__1__Impl rule__Attribute__Group__2 ;
    public final void rule__Attribute__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4390:1: ( rule__Attribute__Group__1__Impl rule__Attribute__Group__2 )
            // InternalSolverLanguageParser.g:4391:2: rule__Attribute__Group__1__Impl rule__Attribute__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__Attribute__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Attribute__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Attribute__Group__1__Impl"
    // InternalSolverLanguageParser.g:4398:1: rule__Attribute__Group__1__Impl : ( ( rule__Attribute__TargetAssignment_1 ) ) ;
    public final void rule__Attribute__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4402:1: ( ( ( rule__Attribute__TargetAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:4403:1: ( ( rule__Attribute__TargetAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:4403:1: ( ( rule__Attribute__TargetAssignment_1 ) )
            // InternalSolverLanguageParser.g:4404:2: ( rule__Attribute__TargetAssignment_1 )
            {
             before(grammarAccess.getAttributeAccess().getTargetAssignment_1()); 
            // InternalSolverLanguageParser.g:4405:2: ( rule__Attribute__TargetAssignment_1 )
            // InternalSolverLanguageParser.g:4405:3: rule__Attribute__TargetAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__Attribute__TargetAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getAttributeAccess().getTargetAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Attribute__Group__2"
    // InternalSolverLanguageParser.g:4413:1: rule__Attribute__Group__2 : rule__Attribute__Group__2__Impl ;
    public final void rule__Attribute__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4417:1: ( rule__Attribute__Group__2__Impl )
            // InternalSolverLanguageParser.g:4418:2: rule__Attribute__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Attribute__Group__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Attribute__Group__2__Impl"
    // InternalSolverLanguageParser.g:4424:1: rule__Attribute__Group__2__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__Attribute__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4428:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:4429:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:4429:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:4430:2: RULE_FULL_STOP
            {
             before(grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__0"
    // InternalSolverLanguageParser.g:4440:1: rule__ExternPredicateDeclaration__Group__0 : rule__ExternPredicateDeclaration__Group__0__Impl rule__ExternPredicateDeclaration__Group__1 ;
    public final void rule__ExternPredicateDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4444:1: ( rule__ExternPredicateDeclaration__Group__0__Impl rule__ExternPredicateDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:4445:2: rule__ExternPredicateDeclaration__Group__0__Impl rule__ExternPredicateDeclaration__Group__1
            {
            pushFollow(FOLLOW_20);
            rule__ExternPredicateDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:4452:1: rule__ExternPredicateDeclaration__Group__0__Impl : ( Extern ) ;
    public final void rule__ExternPredicateDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4456:1: ( ( Extern ) )
            // InternalSolverLanguageParser.g:4457:1: ( Extern )
            {
            // InternalSolverLanguageParser.g:4457:1: ( Extern )
            // InternalSolverLanguageParser.g:4458:2: Extern
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); 
            match(input,Extern,FOLLOW_2); 
             after(grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__1"
    // InternalSolverLanguageParser.g:4467:1: rule__ExternPredicateDeclaration__Group__1 : rule__ExternPredicateDeclaration__Group__1__Impl rule__ExternPredicateDeclaration__Group__2 ;
    public final void rule__ExternPredicateDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4471:1: ( rule__ExternPredicateDeclaration__Group__1__Impl rule__ExternPredicateDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:4472:2: rule__ExternPredicateDeclaration__Group__1__Impl rule__ExternPredicateDeclaration__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__ExternPredicateDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:4479:1: rule__ExternPredicateDeclaration__Group__1__Impl : ( ( rule__ExternPredicateDeclaration__UnorderedGroup_1 ) ) ;
    public final void rule__ExternPredicateDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4483:1: ( ( ( rule__ExternPredicateDeclaration__UnorderedGroup_1 ) ) )
            // InternalSolverLanguageParser.g:4484:1: ( ( rule__ExternPredicateDeclaration__UnorderedGroup_1 ) )
            {
            // InternalSolverLanguageParser.g:4484:1: ( ( rule__ExternPredicateDeclaration__UnorderedGroup_1 ) )
            // InternalSolverLanguageParser.g:4485:2: ( rule__ExternPredicateDeclaration__UnorderedGroup_1 )
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); 
            // InternalSolverLanguageParser.g:4486:2: ( rule__ExternPredicateDeclaration__UnorderedGroup_1 )
            // InternalSolverLanguageParser.g:4486:3: rule__ExternPredicateDeclaration__UnorderedGroup_1
            {
            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__UnorderedGroup_1();

            state._fsp--;


            }

             after(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__2"
    // InternalSolverLanguageParser.g:4494:1: rule__ExternPredicateDeclaration__Group__2 : rule__ExternPredicateDeclaration__Group__2__Impl rule__ExternPredicateDeclaration__Group__3 ;
    public final void rule__ExternPredicateDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4498:1: ( rule__ExternPredicateDeclaration__Group__2__Impl rule__ExternPredicateDeclaration__Group__3 )
            // InternalSolverLanguageParser.g:4499:2: rule__ExternPredicateDeclaration__Group__2__Impl rule__ExternPredicateDeclaration__Group__3
            {
            pushFollow(FOLLOW_16);
            rule__ExternPredicateDeclaration__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:4506:1: rule__ExternPredicateDeclaration__Group__2__Impl : ( ( rule__ExternPredicateDeclaration__NameAssignment_2 ) ) ;
    public final void rule__ExternPredicateDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4510:1: ( ( ( rule__ExternPredicateDeclaration__NameAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:4511:1: ( ( rule__ExternPredicateDeclaration__NameAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:4511:1: ( ( rule__ExternPredicateDeclaration__NameAssignment_2 ) )
            // InternalSolverLanguageParser.g:4512:2: ( rule__ExternPredicateDeclaration__NameAssignment_2 )
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getNameAssignment_2()); 
            // InternalSolverLanguageParser.g:4513:2: ( rule__ExternPredicateDeclaration__NameAssignment_2 )
            // InternalSolverLanguageParser.g:4513:3: rule__ExternPredicateDeclaration__NameAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__NameAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getExternPredicateDeclarationAccess().getNameAssignment_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__3"
    // InternalSolverLanguageParser.g:4521:1: rule__ExternPredicateDeclaration__Group__3 : rule__ExternPredicateDeclaration__Group__3__Impl rule__ExternPredicateDeclaration__Group__4 ;
    public final void rule__ExternPredicateDeclaration__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4525:1: ( rule__ExternPredicateDeclaration__Group__3__Impl rule__ExternPredicateDeclaration__Group__4 )
            // InternalSolverLanguageParser.g:4526:2: rule__ExternPredicateDeclaration__Group__3__Impl rule__ExternPredicateDeclaration__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__ExternPredicateDeclaration__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__3__Impl"
    // InternalSolverLanguageParser.g:4533:1: rule__ExternPredicateDeclaration__Group__3__Impl : ( ( rule__ExternPredicateDeclaration__ArgumentListAssignment_3 ) ) ;
    public final void rule__ExternPredicateDeclaration__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4537:1: ( ( ( rule__ExternPredicateDeclaration__ArgumentListAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:4538:1: ( ( rule__ExternPredicateDeclaration__ArgumentListAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:4538:1: ( ( rule__ExternPredicateDeclaration__ArgumentListAssignment_3 ) )
            // InternalSolverLanguageParser.g:4539:2: ( rule__ExternPredicateDeclaration__ArgumentListAssignment_3 )
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListAssignment_3()); 
            // InternalSolverLanguageParser.g:4540:2: ( rule__ExternPredicateDeclaration__ArgumentListAssignment_3 )
            // InternalSolverLanguageParser.g:4540:3: rule__ExternPredicateDeclaration__ArgumentListAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__ArgumentListAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__4"
    // InternalSolverLanguageParser.g:4548:1: rule__ExternPredicateDeclaration__Group__4 : rule__ExternPredicateDeclaration__Group__4__Impl ;
    public final void rule__ExternPredicateDeclaration__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4552:1: ( rule__ExternPredicateDeclaration__Group__4__Impl )
            // InternalSolverLanguageParser.g:4553:2: rule__ExternPredicateDeclaration__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__Group__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternPredicateDeclaration__Group__4__Impl"
    // InternalSolverLanguageParser.g:4559:1: rule__ExternPredicateDeclaration__Group__4__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__ExternPredicateDeclaration__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4563:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:4564:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:4564:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:4565:2: RULE_FULL_STOP
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__0"
    // InternalSolverLanguageParser.g:4575:1: rule__ExternFunctionDeclaration__Group__0 : rule__ExternFunctionDeclaration__Group__0__Impl rule__ExternFunctionDeclaration__Group__1 ;
    public final void rule__ExternFunctionDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4579:1: ( rule__ExternFunctionDeclaration__Group__0__Impl rule__ExternFunctionDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:4580:2: rule__ExternFunctionDeclaration__Group__0__Impl rule__ExternFunctionDeclaration__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__ExternFunctionDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:4587:1: rule__ExternFunctionDeclaration__Group__0__Impl : ( Extern ) ;
    public final void rule__ExternFunctionDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4591:1: ( ( Extern ) )
            // InternalSolverLanguageParser.g:4592:1: ( Extern )
            {
            // InternalSolverLanguageParser.g:4592:1: ( Extern )
            // InternalSolverLanguageParser.g:4593:2: Extern
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); 
            match(input,Extern,FOLLOW_2); 
             after(grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__1"
    // InternalSolverLanguageParser.g:4602:1: rule__ExternFunctionDeclaration__Group__1 : rule__ExternFunctionDeclaration__Group__1__Impl rule__ExternFunctionDeclaration__Group__2 ;
    public final void rule__ExternFunctionDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4606:1: ( rule__ExternFunctionDeclaration__Group__1__Impl rule__ExternFunctionDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:4607:2: rule__ExternFunctionDeclaration__Group__1__Impl rule__ExternFunctionDeclaration__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__ExternFunctionDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:4614:1: rule__ExternFunctionDeclaration__Group__1__Impl : ( ( rule__ExternFunctionDeclaration__ResultTypeAssignment_1 ) ) ;
    public final void rule__ExternFunctionDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4618:1: ( ( ( rule__ExternFunctionDeclaration__ResultTypeAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:4619:1: ( ( rule__ExternFunctionDeclaration__ResultTypeAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:4619:1: ( ( rule__ExternFunctionDeclaration__ResultTypeAssignment_1 ) )
            // InternalSolverLanguageParser.g:4620:2: ( rule__ExternFunctionDeclaration__ResultTypeAssignment_1 )
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeAssignment_1()); 
            // InternalSolverLanguageParser.g:4621:2: ( rule__ExternFunctionDeclaration__ResultTypeAssignment_1 )
            // InternalSolverLanguageParser.g:4621:3: rule__ExternFunctionDeclaration__ResultTypeAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__ResultTypeAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__2"
    // InternalSolverLanguageParser.g:4629:1: rule__ExternFunctionDeclaration__Group__2 : rule__ExternFunctionDeclaration__Group__2__Impl rule__ExternFunctionDeclaration__Group__3 ;
    public final void rule__ExternFunctionDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4633:1: ( rule__ExternFunctionDeclaration__Group__2__Impl rule__ExternFunctionDeclaration__Group__3 )
            // InternalSolverLanguageParser.g:4634:2: rule__ExternFunctionDeclaration__Group__2__Impl rule__ExternFunctionDeclaration__Group__3
            {
            pushFollow(FOLLOW_16);
            rule__ExternFunctionDeclaration__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:4641:1: rule__ExternFunctionDeclaration__Group__2__Impl : ( ( rule__ExternFunctionDeclaration__NameAssignment_2 ) ) ;
    public final void rule__ExternFunctionDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4645:1: ( ( ( rule__ExternFunctionDeclaration__NameAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:4646:1: ( ( rule__ExternFunctionDeclaration__NameAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:4646:1: ( ( rule__ExternFunctionDeclaration__NameAssignment_2 ) )
            // InternalSolverLanguageParser.g:4647:2: ( rule__ExternFunctionDeclaration__NameAssignment_2 )
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getNameAssignment_2()); 
            // InternalSolverLanguageParser.g:4648:2: ( rule__ExternFunctionDeclaration__NameAssignment_2 )
            // InternalSolverLanguageParser.g:4648:3: rule__ExternFunctionDeclaration__NameAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__NameAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getExternFunctionDeclarationAccess().getNameAssignment_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__3"
    // InternalSolverLanguageParser.g:4656:1: rule__ExternFunctionDeclaration__Group__3 : rule__ExternFunctionDeclaration__Group__3__Impl rule__ExternFunctionDeclaration__Group__4 ;
    public final void rule__ExternFunctionDeclaration__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4660:1: ( rule__ExternFunctionDeclaration__Group__3__Impl rule__ExternFunctionDeclaration__Group__4 )
            // InternalSolverLanguageParser.g:4661:2: rule__ExternFunctionDeclaration__Group__3__Impl rule__ExternFunctionDeclaration__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__ExternFunctionDeclaration__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__3__Impl"
    // InternalSolverLanguageParser.g:4668:1: rule__ExternFunctionDeclaration__Group__3__Impl : ( ( rule__ExternFunctionDeclaration__ArgumentListAssignment_3 ) ) ;
    public final void rule__ExternFunctionDeclaration__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4672:1: ( ( ( rule__ExternFunctionDeclaration__ArgumentListAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:4673:1: ( ( rule__ExternFunctionDeclaration__ArgumentListAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:4673:1: ( ( rule__ExternFunctionDeclaration__ArgumentListAssignment_3 ) )
            // InternalSolverLanguageParser.g:4674:2: ( rule__ExternFunctionDeclaration__ArgumentListAssignment_3 )
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListAssignment_3()); 
            // InternalSolverLanguageParser.g:4675:2: ( rule__ExternFunctionDeclaration__ArgumentListAssignment_3 )
            // InternalSolverLanguageParser.g:4675:3: rule__ExternFunctionDeclaration__ArgumentListAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__ArgumentListAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__4"
    // InternalSolverLanguageParser.g:4683:1: rule__ExternFunctionDeclaration__Group__4 : rule__ExternFunctionDeclaration__Group__4__Impl ;
    public final void rule__ExternFunctionDeclaration__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4687:1: ( rule__ExternFunctionDeclaration__Group__4__Impl )
            // InternalSolverLanguageParser.g:4688:2: rule__ExternFunctionDeclaration__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExternFunctionDeclaration__Group__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternFunctionDeclaration__Group__4__Impl"
    // InternalSolverLanguageParser.g:4694:1: rule__ExternFunctionDeclaration__Group__4__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__ExternFunctionDeclaration__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4698:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:4699:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:4699:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:4700:2: RULE_FULL_STOP
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__0"
    // InternalSolverLanguageParser.g:4710:1: rule__ExternAggregationOperatorDeclaration__Group__0 : rule__ExternAggregationOperatorDeclaration__Group__0__Impl rule__ExternAggregationOperatorDeclaration__Group__1 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4714:1: ( rule__ExternAggregationOperatorDeclaration__Group__0__Impl rule__ExternAggregationOperatorDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:4715:2: rule__ExternAggregationOperatorDeclaration__Group__0__Impl rule__ExternAggregationOperatorDeclaration__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__ExternAggregationOperatorDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:4722:1: rule__ExternAggregationOperatorDeclaration__Group__0__Impl : ( Extern ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4726:1: ( ( Extern ) )
            // InternalSolverLanguageParser.g:4727:1: ( Extern )
            {
            // InternalSolverLanguageParser.g:4727:1: ( Extern )
            // InternalSolverLanguageParser.g:4728:2: Extern
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); 
            match(input,Extern,FOLLOW_2); 
             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__1"
    // InternalSolverLanguageParser.g:4737:1: rule__ExternAggregationOperatorDeclaration__Group__1 : rule__ExternAggregationOperatorDeclaration__Group__1__Impl rule__ExternAggregationOperatorDeclaration__Group__2 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4741:1: ( rule__ExternAggregationOperatorDeclaration__Group__1__Impl rule__ExternAggregationOperatorDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:4742:2: rule__ExternAggregationOperatorDeclaration__Group__1__Impl rule__ExternAggregationOperatorDeclaration__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__ExternAggregationOperatorDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:4749:1: rule__ExternAggregationOperatorDeclaration__Group__1__Impl : ( ( rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 ) ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4753:1: ( ( ( rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:4754:1: ( ( rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:4754:1: ( ( rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 ) )
            // InternalSolverLanguageParser.g:4755:2: ( rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 )
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeAssignment_1()); 
            // InternalSolverLanguageParser.g:4756:2: ( rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 )
            // InternalSolverLanguageParser.g:4756:3: rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__2"
    // InternalSolverLanguageParser.g:4764:1: rule__ExternAggregationOperatorDeclaration__Group__2 : rule__ExternAggregationOperatorDeclaration__Group__2__Impl rule__ExternAggregationOperatorDeclaration__Group__3 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4768:1: ( rule__ExternAggregationOperatorDeclaration__Group__2__Impl rule__ExternAggregationOperatorDeclaration__Group__3 )
            // InternalSolverLanguageParser.g:4769:2: rule__ExternAggregationOperatorDeclaration__Group__2__Impl rule__ExternAggregationOperatorDeclaration__Group__3
            {
            pushFollow(FOLLOW_21);
            rule__ExternAggregationOperatorDeclaration__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:4776:1: rule__ExternAggregationOperatorDeclaration__Group__2__Impl : ( ( rule__ExternAggregationOperatorDeclaration__NameAssignment_2 ) ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4780:1: ( ( ( rule__ExternAggregationOperatorDeclaration__NameAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:4781:1: ( ( rule__ExternAggregationOperatorDeclaration__NameAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:4781:1: ( ( rule__ExternAggregationOperatorDeclaration__NameAssignment_2 ) )
            // InternalSolverLanguageParser.g:4782:2: ( rule__ExternAggregationOperatorDeclaration__NameAssignment_2 )
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameAssignment_2()); 
            // InternalSolverLanguageParser.g:4783:2: ( rule__ExternAggregationOperatorDeclaration__NameAssignment_2 )
            // InternalSolverLanguageParser.g:4783:3: rule__ExternAggregationOperatorDeclaration__NameAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__NameAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameAssignment_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__3"
    // InternalSolverLanguageParser.g:4791:1: rule__ExternAggregationOperatorDeclaration__Group__3 : rule__ExternAggregationOperatorDeclaration__Group__3__Impl rule__ExternAggregationOperatorDeclaration__Group__4 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4795:1: ( rule__ExternAggregationOperatorDeclaration__Group__3__Impl rule__ExternAggregationOperatorDeclaration__Group__4 )
            // InternalSolverLanguageParser.g:4796:2: rule__ExternAggregationOperatorDeclaration__Group__3__Impl rule__ExternAggregationOperatorDeclaration__Group__4
            {
            pushFollow(FOLLOW_6);
            rule__ExternAggregationOperatorDeclaration__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__3__Impl"
    // InternalSolverLanguageParser.g:4803:1: rule__ExternAggregationOperatorDeclaration__Group__3__Impl : ( LeftCurlyBracket ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4807:1: ( ( LeftCurlyBracket ) )
            // InternalSolverLanguageParser.g:4808:1: ( LeftCurlyBracket )
            {
            // InternalSolverLanguageParser.g:4808:1: ( LeftCurlyBracket )
            // InternalSolverLanguageParser.g:4809:2: LeftCurlyBracket
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); 
            match(input,LeftCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__4"
    // InternalSolverLanguageParser.g:4818:1: rule__ExternAggregationOperatorDeclaration__Group__4 : rule__ExternAggregationOperatorDeclaration__Group__4__Impl rule__ExternAggregationOperatorDeclaration__Group__5 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4822:1: ( rule__ExternAggregationOperatorDeclaration__Group__4__Impl rule__ExternAggregationOperatorDeclaration__Group__5 )
            // InternalSolverLanguageParser.g:4823:2: rule__ExternAggregationOperatorDeclaration__Group__4__Impl rule__ExternAggregationOperatorDeclaration__Group__5
            {
            pushFollow(FOLLOW_22);
            rule__ExternAggregationOperatorDeclaration__Group__4__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__5();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__4__Impl"
    // InternalSolverLanguageParser.g:4830:1: rule__ExternAggregationOperatorDeclaration__Group__4__Impl : ( ( rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 ) ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4834:1: ( ( ( rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 ) ) )
            // InternalSolverLanguageParser.g:4835:1: ( ( rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 ) )
            {
            // InternalSolverLanguageParser.g:4835:1: ( ( rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 ) )
            // InternalSolverLanguageParser.g:4836:2: ( rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 )
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeAssignment_4()); 
            // InternalSolverLanguageParser.g:4837:2: ( rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 )
            // InternalSolverLanguageParser.g:4837:3: rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4();

            state._fsp--;


            }

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeAssignment_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__5"
    // InternalSolverLanguageParser.g:4845:1: rule__ExternAggregationOperatorDeclaration__Group__5 : rule__ExternAggregationOperatorDeclaration__Group__5__Impl rule__ExternAggregationOperatorDeclaration__Group__6 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4849:1: ( rule__ExternAggregationOperatorDeclaration__Group__5__Impl rule__ExternAggregationOperatorDeclaration__Group__6 )
            // InternalSolverLanguageParser.g:4850:2: rule__ExternAggregationOperatorDeclaration__Group__5__Impl rule__ExternAggregationOperatorDeclaration__Group__6
            {
            pushFollow(FOLLOW_23);
            rule__ExternAggregationOperatorDeclaration__Group__5__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__6();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__5__Impl"
    // InternalSolverLanguageParser.g:4857:1: rule__ExternAggregationOperatorDeclaration__Group__5__Impl : ( FullStopFullStopFullStop ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4861:1: ( ( FullStopFullStopFullStop ) )
            // InternalSolverLanguageParser.g:4862:1: ( FullStopFullStopFullStop )
            {
            // InternalSolverLanguageParser.g:4862:1: ( FullStopFullStopFullStop )
            // InternalSolverLanguageParser.g:4863:2: FullStopFullStopFullStop
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); 
            match(input,FullStopFullStopFullStop,FOLLOW_2); 
             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__6"
    // InternalSolverLanguageParser.g:4872:1: rule__ExternAggregationOperatorDeclaration__Group__6 : rule__ExternAggregationOperatorDeclaration__Group__6__Impl rule__ExternAggregationOperatorDeclaration__Group__7 ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4876:1: ( rule__ExternAggregationOperatorDeclaration__Group__6__Impl rule__ExternAggregationOperatorDeclaration__Group__7 )
            // InternalSolverLanguageParser.g:4877:2: rule__ExternAggregationOperatorDeclaration__Group__6__Impl rule__ExternAggregationOperatorDeclaration__Group__7
            {
            pushFollow(FOLLOW_7);
            rule__ExternAggregationOperatorDeclaration__Group__6__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__7();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__6__Impl"
    // InternalSolverLanguageParser.g:4884:1: rule__ExternAggregationOperatorDeclaration__Group__6__Impl : ( RightCurlyBracket ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4888:1: ( ( RightCurlyBracket ) )
            // InternalSolverLanguageParser.g:4889:1: ( RightCurlyBracket )
            {
            // InternalSolverLanguageParser.g:4889:1: ( RightCurlyBracket )
            // InternalSolverLanguageParser.g:4890:2: RightCurlyBracket
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); 
            match(input,RightCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__7"
    // InternalSolverLanguageParser.g:4899:1: rule__ExternAggregationOperatorDeclaration__Group__7 : rule__ExternAggregationOperatorDeclaration__Group__7__Impl ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4903:1: ( rule__ExternAggregationOperatorDeclaration__Group__7__Impl )
            // InternalSolverLanguageParser.g:4904:2: rule__ExternAggregationOperatorDeclaration__Group__7__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExternAggregationOperatorDeclaration__Group__7__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__Group__7__Impl"
    // InternalSolverLanguageParser.g:4910:1: rule__ExternAggregationOperatorDeclaration__Group__7__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__ExternAggregationOperatorDeclaration__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4914:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:4915:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:4915:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:4916:2: RULE_FULL_STOP
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__0"
    // InternalSolverLanguageParser.g:4926:1: rule__ExternDatatypeDeclaration__Group__0 : rule__ExternDatatypeDeclaration__Group__0__Impl rule__ExternDatatypeDeclaration__Group__1 ;
    public final void rule__ExternDatatypeDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4930:1: ( rule__ExternDatatypeDeclaration__Group__0__Impl rule__ExternDatatypeDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:4931:2: rule__ExternDatatypeDeclaration__Group__0__Impl rule__ExternDatatypeDeclaration__Group__1
            {
            pushFollow(FOLLOW_24);
            rule__ExternDatatypeDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternDatatypeDeclaration__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:4938:1: rule__ExternDatatypeDeclaration__Group__0__Impl : ( Extern ) ;
    public final void rule__ExternDatatypeDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4942:1: ( ( Extern ) )
            // InternalSolverLanguageParser.g:4943:1: ( Extern )
            {
            // InternalSolverLanguageParser.g:4943:1: ( Extern )
            // InternalSolverLanguageParser.g:4944:2: Extern
            {
             before(grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); 
            match(input,Extern,FOLLOW_2); 
             after(grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__1"
    // InternalSolverLanguageParser.g:4953:1: rule__ExternDatatypeDeclaration__Group__1 : rule__ExternDatatypeDeclaration__Group__1__Impl rule__ExternDatatypeDeclaration__Group__2 ;
    public final void rule__ExternDatatypeDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4957:1: ( rule__ExternDatatypeDeclaration__Group__1__Impl rule__ExternDatatypeDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:4958:2: rule__ExternDatatypeDeclaration__Group__1__Impl rule__ExternDatatypeDeclaration__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__ExternDatatypeDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternDatatypeDeclaration__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:4965:1: rule__ExternDatatypeDeclaration__Group__1__Impl : ( Datatype ) ;
    public final void rule__ExternDatatypeDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4969:1: ( ( Datatype ) )
            // InternalSolverLanguageParser.g:4970:1: ( Datatype )
            {
            // InternalSolverLanguageParser.g:4970:1: ( Datatype )
            // InternalSolverLanguageParser.g:4971:2: Datatype
            {
             before(grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); 
            match(input,Datatype,FOLLOW_2); 
             after(grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__2"
    // InternalSolverLanguageParser.g:4980:1: rule__ExternDatatypeDeclaration__Group__2 : rule__ExternDatatypeDeclaration__Group__2__Impl rule__ExternDatatypeDeclaration__Group__3 ;
    public final void rule__ExternDatatypeDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4984:1: ( rule__ExternDatatypeDeclaration__Group__2__Impl rule__ExternDatatypeDeclaration__Group__3 )
            // InternalSolverLanguageParser.g:4985:2: rule__ExternDatatypeDeclaration__Group__2__Impl rule__ExternDatatypeDeclaration__Group__3
            {
            pushFollow(FOLLOW_7);
            rule__ExternDatatypeDeclaration__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExternDatatypeDeclaration__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:4992:1: rule__ExternDatatypeDeclaration__Group__2__Impl : ( ( rule__ExternDatatypeDeclaration__NameAssignment_2 ) ) ;
    public final void rule__ExternDatatypeDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:4996:1: ( ( ( rule__ExternDatatypeDeclaration__NameAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:4997:1: ( ( rule__ExternDatatypeDeclaration__NameAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:4997:1: ( ( rule__ExternDatatypeDeclaration__NameAssignment_2 ) )
            // InternalSolverLanguageParser.g:4998:2: ( rule__ExternDatatypeDeclaration__NameAssignment_2 )
            {
             before(grammarAccess.getExternDatatypeDeclarationAccess().getNameAssignment_2()); 
            // InternalSolverLanguageParser.g:4999:2: ( rule__ExternDatatypeDeclaration__NameAssignment_2 )
            // InternalSolverLanguageParser.g:4999:3: rule__ExternDatatypeDeclaration__NameAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ExternDatatypeDeclaration__NameAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getExternDatatypeDeclarationAccess().getNameAssignment_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__3"
    // InternalSolverLanguageParser.g:5007:1: rule__ExternDatatypeDeclaration__Group__3 : rule__ExternDatatypeDeclaration__Group__3__Impl ;
    public final void rule__ExternDatatypeDeclaration__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5011:1: ( rule__ExternDatatypeDeclaration__Group__3__Impl )
            // InternalSolverLanguageParser.g:5012:2: rule__ExternDatatypeDeclaration__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExternDatatypeDeclaration__Group__3__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExternDatatypeDeclaration__Group__3__Impl"
    // InternalSolverLanguageParser.g:5018:1: rule__ExternDatatypeDeclaration__Group__3__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__ExternDatatypeDeclaration__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5022:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:5023:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:5023:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:5024:2: RULE_FULL_STOP
            {
             before(grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2__0"
    // InternalSolverLanguageParser.g:5034:1: rule__Expression__Group_2__0 : rule__Expression__Group_2__0__Impl rule__Expression__Group_2__1 ;
    public final void rule__Expression__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5038:1: ( rule__Expression__Group_2__0__Impl rule__Expression__Group_2__1 )
            // InternalSolverLanguageParser.g:5039:2: rule__Expression__Group_2__0__Impl rule__Expression__Group_2__1
            {
            pushFollow(FOLLOW_25);
            rule__Expression__Group_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Expression__Group_2__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2__0__Impl"
    // InternalSolverLanguageParser.g:5046:1: rule__Expression__Group_2__0__Impl : ( ruleDisjunctiveExpression ) ;
    public final void rule__Expression__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5050:1: ( ( ruleDisjunctiveExpression ) )
            // InternalSolverLanguageParser.g:5051:1: ( ruleDisjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:5051:1: ( ruleDisjunctiveExpression )
            // InternalSolverLanguageParser.g:5052:2: ruleDisjunctiveExpression
            {
             before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleDisjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2__1"
    // InternalSolverLanguageParser.g:5061:1: rule__Expression__Group_2__1 : rule__Expression__Group_2__1__Impl ;
    public final void rule__Expression__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5065:1: ( rule__Expression__Group_2__1__Impl )
            // InternalSolverLanguageParser.g:5066:2: rule__Expression__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Expression__Group_2__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2__1__Impl"
    // InternalSolverLanguageParser.g:5072:1: rule__Expression__Group_2__1__Impl : ( ( rule__Expression__Group_2_1__0 )? ) ;
    public final void rule__Expression__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5076:1: ( ( ( rule__Expression__Group_2_1__0 )? ) )
            // InternalSolverLanguageParser.g:5077:1: ( ( rule__Expression__Group_2_1__0 )? )
            {
            // InternalSolverLanguageParser.g:5077:1: ( ( rule__Expression__Group_2_1__0 )? )
            // InternalSolverLanguageParser.g:5078:2: ( rule__Expression__Group_2_1__0 )?
            {
             before(grammarAccess.getExpressionAccess().getGroup_2_1()); 
            // InternalSolverLanguageParser.g:5079:2: ( rule__Expression__Group_2_1__0 )?
            int alt38=2;
            int LA38_0 = input.LA(1);

            if ( (LA38_0==EqualsSignGreaterThanSign) ) {
                alt38=1;
            }
            switch (alt38) {
                case 1 :
                    // InternalSolverLanguageParser.g:5079:3: rule__Expression__Group_2_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__Expression__Group_2_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getExpressionAccess().getGroup_2_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2_1__0"
    // InternalSolverLanguageParser.g:5088:1: rule__Expression__Group_2_1__0 : rule__Expression__Group_2_1__0__Impl rule__Expression__Group_2_1__1 ;
    public final void rule__Expression__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5092:1: ( rule__Expression__Group_2_1__0__Impl rule__Expression__Group_2_1__1 )
            // InternalSolverLanguageParser.g:5093:2: rule__Expression__Group_2_1__0__Impl rule__Expression__Group_2_1__1
            {
            pushFollow(FOLLOW_25);
            rule__Expression__Group_2_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Expression__Group_2_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2_1__0__Impl"
    // InternalSolverLanguageParser.g:5100:1: rule__Expression__Group_2_1__0__Impl : ( () ) ;
    public final void rule__Expression__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5104:1: ( ( () ) )
            // InternalSolverLanguageParser.g:5105:1: ( () )
            {
            // InternalSolverLanguageParser.g:5105:1: ( () )
            // InternalSolverLanguageParser.g:5106:2: ()
            {
             before(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0()); 
            // InternalSolverLanguageParser.g:5107:2: ()
            // InternalSolverLanguageParser.g:5107:3: 
            {
            }

             after(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2_1__1"
    // InternalSolverLanguageParser.g:5115:1: rule__Expression__Group_2_1__1 : rule__Expression__Group_2_1__1__Impl rule__Expression__Group_2_1__2 ;
    public final void rule__Expression__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5119:1: ( rule__Expression__Group_2_1__1__Impl rule__Expression__Group_2_1__2 )
            // InternalSolverLanguageParser.g:5120:2: rule__Expression__Group_2_1__1__Impl rule__Expression__Group_2_1__2
            {
            pushFollow(FOLLOW_12);
            rule__Expression__Group_2_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Expression__Group_2_1__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2_1__1__Impl"
    // InternalSolverLanguageParser.g:5127:1: rule__Expression__Group_2_1__1__Impl : ( EqualsSignGreaterThanSign ) ;
    public final void rule__Expression__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5131:1: ( ( EqualsSignGreaterThanSign ) )
            // InternalSolverLanguageParser.g:5132:1: ( EqualsSignGreaterThanSign )
            {
            // InternalSolverLanguageParser.g:5132:1: ( EqualsSignGreaterThanSign )
            // InternalSolverLanguageParser.g:5133:2: EqualsSignGreaterThanSign
            {
             before(grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); 
            match(input,EqualsSignGreaterThanSign,FOLLOW_2); 
             after(grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2_1__2"
    // InternalSolverLanguageParser.g:5142:1: rule__Expression__Group_2_1__2 : rule__Expression__Group_2_1__2__Impl ;
    public final void rule__Expression__Group_2_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5146:1: ( rule__Expression__Group_2_1__2__Impl )
            // InternalSolverLanguageParser.g:5147:2: rule__Expression__Group_2_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Expression__Group_2_1__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Expression__Group_2_1__2__Impl"
    // InternalSolverLanguageParser.g:5153:1: rule__Expression__Group_2_1__2__Impl : ( ( rule__Expression__BodyAssignment_2_1_2 ) ) ;
    public final void rule__Expression__Group_2_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5157:1: ( ( ( rule__Expression__BodyAssignment_2_1_2 ) ) )
            // InternalSolverLanguageParser.g:5158:1: ( ( rule__Expression__BodyAssignment_2_1_2 ) )
            {
            // InternalSolverLanguageParser.g:5158:1: ( ( rule__Expression__BodyAssignment_2_1_2 ) )
            // InternalSolverLanguageParser.g:5159:2: ( rule__Expression__BodyAssignment_2_1_2 )
            {
             before(grammarAccess.getExpressionAccess().getBodyAssignment_2_1_2()); 
            // InternalSolverLanguageParser.g:5160:2: ( rule__Expression__BodyAssignment_2_1_2 )
            // InternalSolverLanguageParser.g:5160:3: rule__Expression__BodyAssignment_2_1_2
            {
            pushFollow(FOLLOW_2);
            rule__Expression__BodyAssignment_2_1_2();

            state._fsp--;


            }

             after(grammarAccess.getExpressionAccess().getBodyAssignment_2_1_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__0"
    // InternalSolverLanguageParser.g:5169:1: rule__ConditionalExpression__Group__0 : rule__ConditionalExpression__Group__0__Impl rule__ConditionalExpression__Group__1 ;
    public final void rule__ConditionalExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5173:1: ( rule__ConditionalExpression__Group__0__Impl rule__ConditionalExpression__Group__1 )
            // InternalSolverLanguageParser.g:5174:2: rule__ConditionalExpression__Group__0__Impl rule__ConditionalExpression__Group__1
            {
            pushFollow(FOLLOW_12);
            rule__ConditionalExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:5181:1: rule__ConditionalExpression__Group__0__Impl : ( If ) ;
    public final void rule__ConditionalExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5185:1: ( ( If ) )
            // InternalSolverLanguageParser.g:5186:1: ( If )
            {
            // InternalSolverLanguageParser.g:5186:1: ( If )
            // InternalSolverLanguageParser.g:5187:2: If
            {
             before(grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); 
            match(input,If,FOLLOW_2); 
             after(grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__1"
    // InternalSolverLanguageParser.g:5196:1: rule__ConditionalExpression__Group__1 : rule__ConditionalExpression__Group__1__Impl rule__ConditionalExpression__Group__2 ;
    public final void rule__ConditionalExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5200:1: ( rule__ConditionalExpression__Group__1__Impl rule__ConditionalExpression__Group__2 )
            // InternalSolverLanguageParser.g:5201:2: rule__ConditionalExpression__Group__1__Impl rule__ConditionalExpression__Group__2
            {
            pushFollow(FOLLOW_26);
            rule__ConditionalExpression__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:5208:1: rule__ConditionalExpression__Group__1__Impl : ( ( rule__ConditionalExpression__ConditionAssignment_1 ) ) ;
    public final void rule__ConditionalExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5212:1: ( ( ( rule__ConditionalExpression__ConditionAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:5213:1: ( ( rule__ConditionalExpression__ConditionAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:5213:1: ( ( rule__ConditionalExpression__ConditionAssignment_1 ) )
            // InternalSolverLanguageParser.g:5214:2: ( rule__ConditionalExpression__ConditionAssignment_1 )
            {
             before(grammarAccess.getConditionalExpressionAccess().getConditionAssignment_1()); 
            // InternalSolverLanguageParser.g:5215:2: ( rule__ConditionalExpression__ConditionAssignment_1 )
            // InternalSolverLanguageParser.g:5215:3: rule__ConditionalExpression__ConditionAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__ConditionAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getConditionalExpressionAccess().getConditionAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__2"
    // InternalSolverLanguageParser.g:5223:1: rule__ConditionalExpression__Group__2 : rule__ConditionalExpression__Group__2__Impl rule__ConditionalExpression__Group__3 ;
    public final void rule__ConditionalExpression__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5227:1: ( rule__ConditionalExpression__Group__2__Impl rule__ConditionalExpression__Group__3 )
            // InternalSolverLanguageParser.g:5228:2: rule__ConditionalExpression__Group__2__Impl rule__ConditionalExpression__Group__3
            {
            pushFollow(FOLLOW_12);
            rule__ConditionalExpression__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__2__Impl"
    // InternalSolverLanguageParser.g:5235:1: rule__ConditionalExpression__Group__2__Impl : ( Then ) ;
    public final void rule__ConditionalExpression__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5239:1: ( ( Then ) )
            // InternalSolverLanguageParser.g:5240:1: ( Then )
            {
            // InternalSolverLanguageParser.g:5240:1: ( Then )
            // InternalSolverLanguageParser.g:5241:2: Then
            {
             before(grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); 
            match(input,Then,FOLLOW_2); 
             after(grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__3"
    // InternalSolverLanguageParser.g:5250:1: rule__ConditionalExpression__Group__3 : rule__ConditionalExpression__Group__3__Impl rule__ConditionalExpression__Group__4 ;
    public final void rule__ConditionalExpression__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5254:1: ( rule__ConditionalExpression__Group__3__Impl rule__ConditionalExpression__Group__4 )
            // InternalSolverLanguageParser.g:5255:2: rule__ConditionalExpression__Group__3__Impl rule__ConditionalExpression__Group__4
            {
            pushFollow(FOLLOW_27);
            rule__ConditionalExpression__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__3__Impl"
    // InternalSolverLanguageParser.g:5262:1: rule__ConditionalExpression__Group__3__Impl : ( ( rule__ConditionalExpression__ThenAssignment_3 ) ) ;
    public final void rule__ConditionalExpression__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5266:1: ( ( ( rule__ConditionalExpression__ThenAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:5267:1: ( ( rule__ConditionalExpression__ThenAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:5267:1: ( ( rule__ConditionalExpression__ThenAssignment_3 ) )
            // InternalSolverLanguageParser.g:5268:2: ( rule__ConditionalExpression__ThenAssignment_3 )
            {
             before(grammarAccess.getConditionalExpressionAccess().getThenAssignment_3()); 
            // InternalSolverLanguageParser.g:5269:2: ( rule__ConditionalExpression__ThenAssignment_3 )
            // InternalSolverLanguageParser.g:5269:3: rule__ConditionalExpression__ThenAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__ThenAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getConditionalExpressionAccess().getThenAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__4"
    // InternalSolverLanguageParser.g:5277:1: rule__ConditionalExpression__Group__4 : rule__ConditionalExpression__Group__4__Impl rule__ConditionalExpression__Group__5 ;
    public final void rule__ConditionalExpression__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5281:1: ( rule__ConditionalExpression__Group__4__Impl rule__ConditionalExpression__Group__5 )
            // InternalSolverLanguageParser.g:5282:2: rule__ConditionalExpression__Group__4__Impl rule__ConditionalExpression__Group__5
            {
            pushFollow(FOLLOW_12);
            rule__ConditionalExpression__Group__4__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__5();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__4__Impl"
    // InternalSolverLanguageParser.g:5289:1: rule__ConditionalExpression__Group__4__Impl : ( Else ) ;
    public final void rule__ConditionalExpression__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5293:1: ( ( Else ) )
            // InternalSolverLanguageParser.g:5294:1: ( Else )
            {
            // InternalSolverLanguageParser.g:5294:1: ( Else )
            // InternalSolverLanguageParser.g:5295:2: Else
            {
             before(grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); 
            match(input,Else,FOLLOW_2); 
             after(grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__5"
    // InternalSolverLanguageParser.g:5304:1: rule__ConditionalExpression__Group__5 : rule__ConditionalExpression__Group__5__Impl ;
    public final void rule__ConditionalExpression__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5308:1: ( rule__ConditionalExpression__Group__5__Impl )
            // InternalSolverLanguageParser.g:5309:2: rule__ConditionalExpression__Group__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__Group__5__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConditionalExpression__Group__5__Impl"
    // InternalSolverLanguageParser.g:5315:1: rule__ConditionalExpression__Group__5__Impl : ( ( rule__ConditionalExpression__ElseAssignment_5 ) ) ;
    public final void rule__ConditionalExpression__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5319:1: ( ( ( rule__ConditionalExpression__ElseAssignment_5 ) ) )
            // InternalSolverLanguageParser.g:5320:1: ( ( rule__ConditionalExpression__ElseAssignment_5 ) )
            {
            // InternalSolverLanguageParser.g:5320:1: ( ( rule__ConditionalExpression__ElseAssignment_5 ) )
            // InternalSolverLanguageParser.g:5321:2: ( rule__ConditionalExpression__ElseAssignment_5 )
            {
             before(grammarAccess.getConditionalExpressionAccess().getElseAssignment_5()); 
            // InternalSolverLanguageParser.g:5322:2: ( rule__ConditionalExpression__ElseAssignment_5 )
            // InternalSolverLanguageParser.g:5322:3: rule__ConditionalExpression__ElseAssignment_5
            {
            pushFollow(FOLLOW_2);
            rule__ConditionalExpression__ElseAssignment_5();

            state._fsp--;


            }

             after(grammarAccess.getConditionalExpressionAccess().getElseAssignment_5()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__0"
    // InternalSolverLanguageParser.g:5331:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ;
    public final void rule__LetExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5335:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 )
            // InternalSolverLanguageParser.g:5336:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__LetExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetExpression__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:5343:1: rule__LetExpression__Group__0__Impl : ( Let ) ;
    public final void rule__LetExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5347:1: ( ( Let ) )
            // InternalSolverLanguageParser.g:5348:1: ( Let )
            {
            // InternalSolverLanguageParser.g:5348:1: ( Let )
            // InternalSolverLanguageParser.g:5349:2: Let
            {
             before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); 
            match(input,Let,FOLLOW_2); 
             after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__1"
    // InternalSolverLanguageParser.g:5358:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ;
    public final void rule__LetExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5362:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 )
            // InternalSolverLanguageParser.g:5363:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2
            {
            pushFollow(FOLLOW_28);
            rule__LetExpression__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetExpression__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:5370:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__BindingsAssignment_1 ) ) ;
    public final void rule__LetExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5374:1: ( ( ( rule__LetExpression__BindingsAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:5375:1: ( ( rule__LetExpression__BindingsAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:5375:1: ( ( rule__LetExpression__BindingsAssignment_1 ) )
            // InternalSolverLanguageParser.g:5376:2: ( rule__LetExpression__BindingsAssignment_1 )
            {
             before(grammarAccess.getLetExpressionAccess().getBindingsAssignment_1()); 
            // InternalSolverLanguageParser.g:5377:2: ( rule__LetExpression__BindingsAssignment_1 )
            // InternalSolverLanguageParser.g:5377:3: rule__LetExpression__BindingsAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__LetExpression__BindingsAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getLetExpressionAccess().getBindingsAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__2"
    // InternalSolverLanguageParser.g:5385:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ;
    public final void rule__LetExpression__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5389:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 )
            // InternalSolverLanguageParser.g:5390:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3
            {
            pushFollow(FOLLOW_28);
            rule__LetExpression__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetExpression__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__2__Impl"
    // InternalSolverLanguageParser.g:5397:1: rule__LetExpression__Group__2__Impl : ( ( rule__LetExpression__Group_2__0 )* ) ;
    public final void rule__LetExpression__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5401:1: ( ( ( rule__LetExpression__Group_2__0 )* ) )
            // InternalSolverLanguageParser.g:5402:1: ( ( rule__LetExpression__Group_2__0 )* )
            {
            // InternalSolverLanguageParser.g:5402:1: ( ( rule__LetExpression__Group_2__0 )* )
            // InternalSolverLanguageParser.g:5403:2: ( rule__LetExpression__Group_2__0 )*
            {
             before(grammarAccess.getLetExpressionAccess().getGroup_2()); 
            // InternalSolverLanguageParser.g:5404:2: ( rule__LetExpression__Group_2__0 )*
            loop39:
            do {
                int alt39=2;
                int LA39_0 = input.LA(1);

                if ( (LA39_0==Comma) ) {
                    alt39=1;
                }


                switch (alt39) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:5404:3: rule__LetExpression__Group_2__0
            	    {
            	    pushFollow(FOLLOW_29);
            	    rule__LetExpression__Group_2__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop39;
                }
            } while (true);

             after(grammarAccess.getLetExpressionAccess().getGroup_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__3"
    // InternalSolverLanguageParser.g:5412:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ;
    public final void rule__LetExpression__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5416:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 )
            // InternalSolverLanguageParser.g:5417:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4
            {
            pushFollow(FOLLOW_12);
            rule__LetExpression__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetExpression__Group__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__3__Impl"
    // InternalSolverLanguageParser.g:5424:1: rule__LetExpression__Group__3__Impl : ( In ) ;
    public final void rule__LetExpression__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5428:1: ( ( In ) )
            // InternalSolverLanguageParser.g:5429:1: ( In )
            {
            // InternalSolverLanguageParser.g:5429:1: ( In )
            // InternalSolverLanguageParser.g:5430:2: In
            {
             before(grammarAccess.getLetExpressionAccess().getInKeyword_3()); 
            match(input,In,FOLLOW_2); 
             after(grammarAccess.getLetExpressionAccess().getInKeyword_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__4"
    // InternalSolverLanguageParser.g:5439:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl ;
    public final void rule__LetExpression__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5443:1: ( rule__LetExpression__Group__4__Impl )
            // InternalSolverLanguageParser.g:5444:2: rule__LetExpression__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LetExpression__Group__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group__4__Impl"
    // InternalSolverLanguageParser.g:5450:1: rule__LetExpression__Group__4__Impl : ( ( rule__LetExpression__BodyAssignment_4 ) ) ;
    public final void rule__LetExpression__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5454:1: ( ( ( rule__LetExpression__BodyAssignment_4 ) ) )
            // InternalSolverLanguageParser.g:5455:1: ( ( rule__LetExpression__BodyAssignment_4 ) )
            {
            // InternalSolverLanguageParser.g:5455:1: ( ( rule__LetExpression__BodyAssignment_4 ) )
            // InternalSolverLanguageParser.g:5456:2: ( rule__LetExpression__BodyAssignment_4 )
            {
             before(grammarAccess.getLetExpressionAccess().getBodyAssignment_4()); 
            // InternalSolverLanguageParser.g:5457:2: ( rule__LetExpression__BodyAssignment_4 )
            // InternalSolverLanguageParser.g:5457:3: rule__LetExpression__BodyAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__LetExpression__BodyAssignment_4();

            state._fsp--;


            }

             after(grammarAccess.getLetExpressionAccess().getBodyAssignment_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group_2__0"
    // InternalSolverLanguageParser.g:5466:1: rule__LetExpression__Group_2__0 : rule__LetExpression__Group_2__0__Impl rule__LetExpression__Group_2__1 ;
    public final void rule__LetExpression__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5470:1: ( rule__LetExpression__Group_2__0__Impl rule__LetExpression__Group_2__1 )
            // InternalSolverLanguageParser.g:5471:2: rule__LetExpression__Group_2__0__Impl rule__LetExpression__Group_2__1
            {
            pushFollow(FOLLOW_6);
            rule__LetExpression__Group_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetExpression__Group_2__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group_2__0__Impl"
    // InternalSolverLanguageParser.g:5478:1: rule__LetExpression__Group_2__0__Impl : ( Comma ) ;
    public final void rule__LetExpression__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5482:1: ( ( Comma ) )
            // InternalSolverLanguageParser.g:5483:1: ( Comma )
            {
            // InternalSolverLanguageParser.g:5483:1: ( Comma )
            // InternalSolverLanguageParser.g:5484:2: Comma
            {
             before(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); 
            match(input,Comma,FOLLOW_2); 
             after(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group_2__1"
    // InternalSolverLanguageParser.g:5493:1: rule__LetExpression__Group_2__1 : rule__LetExpression__Group_2__1__Impl ;
    public final void rule__LetExpression__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5497:1: ( rule__LetExpression__Group_2__1__Impl )
            // InternalSolverLanguageParser.g:5498:2: rule__LetExpression__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LetExpression__Group_2__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetExpression__Group_2__1__Impl"
    // InternalSolverLanguageParser.g:5504:1: rule__LetExpression__Group_2__1__Impl : ( ( rule__LetExpression__BindingsAssignment_2_1 ) ) ;
    public final void rule__LetExpression__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5508:1: ( ( ( rule__LetExpression__BindingsAssignment_2_1 ) ) )
            // InternalSolverLanguageParser.g:5509:1: ( ( rule__LetExpression__BindingsAssignment_2_1 ) )
            {
            // InternalSolverLanguageParser.g:5509:1: ( ( rule__LetExpression__BindingsAssignment_2_1 ) )
            // InternalSolverLanguageParser.g:5510:2: ( rule__LetExpression__BindingsAssignment_2_1 )
            {
             before(grammarAccess.getLetExpressionAccess().getBindingsAssignment_2_1()); 
            // InternalSolverLanguageParser.g:5511:2: ( rule__LetExpression__BindingsAssignment_2_1 )
            // InternalSolverLanguageParser.g:5511:3: rule__LetExpression__BindingsAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__LetExpression__BindingsAssignment_2_1();

            state._fsp--;


            }

             after(grammarAccess.getLetExpressionAccess().getBindingsAssignment_2_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__0"
    // InternalSolverLanguageParser.g:5520:1: rule__LetBinding__Group__0 : rule__LetBinding__Group__0__Impl rule__LetBinding__Group__1 ;
    public final void rule__LetBinding__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5524:1: ( rule__LetBinding__Group__0__Impl rule__LetBinding__Group__1 )
            // InternalSolverLanguageParser.g:5525:2: rule__LetBinding__Group__0__Impl rule__LetBinding__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__LetBinding__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetBinding__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__0__Impl"
    // InternalSolverLanguageParser.g:5532:1: rule__LetBinding__Group__0__Impl : ( ( rule__LetBinding__TypeAssignment_0 )? ) ;
    public final void rule__LetBinding__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5536:1: ( ( ( rule__LetBinding__TypeAssignment_0 )? ) )
            // InternalSolverLanguageParser.g:5537:1: ( ( rule__LetBinding__TypeAssignment_0 )? )
            {
            // InternalSolverLanguageParser.g:5537:1: ( ( rule__LetBinding__TypeAssignment_0 )? )
            // InternalSolverLanguageParser.g:5538:2: ( rule__LetBinding__TypeAssignment_0 )?
            {
             before(grammarAccess.getLetBindingAccess().getTypeAssignment_0()); 
            // InternalSolverLanguageParser.g:5539:2: ( rule__LetBinding__TypeAssignment_0 )?
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( (LA40_0==RULE_ID) ) {
                int LA40_1 = input.LA(2);

                if ( (LA40_1==ColonColon||LA40_1==RULE_ID) ) {
                    alt40=1;
                }
            }
            else if ( (LA40_0==Object||LA40_0==RULE_QUOTED_ID) ) {
                alt40=1;
            }
            switch (alt40) {
                case 1 :
                    // InternalSolverLanguageParser.g:5539:3: rule__LetBinding__TypeAssignment_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LetBinding__TypeAssignment_0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getLetBindingAccess().getTypeAssignment_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__1"
    // InternalSolverLanguageParser.g:5547:1: rule__LetBinding__Group__1 : rule__LetBinding__Group__1__Impl rule__LetBinding__Group__2 ;
    public final void rule__LetBinding__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5551:1: ( rule__LetBinding__Group__1__Impl rule__LetBinding__Group__2 )
            // InternalSolverLanguageParser.g:5552:2: rule__LetBinding__Group__1__Impl rule__LetBinding__Group__2
            {
            pushFollow(FOLLOW_30);
            rule__LetBinding__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetBinding__Group__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__1__Impl"
    // InternalSolverLanguageParser.g:5559:1: rule__LetBinding__Group__1__Impl : ( ( rule__LetBinding__NameAssignment_1 ) ) ;
    public final void rule__LetBinding__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5563:1: ( ( ( rule__LetBinding__NameAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:5564:1: ( ( rule__LetBinding__NameAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:5564:1: ( ( rule__LetBinding__NameAssignment_1 ) )
            // InternalSolverLanguageParser.g:5565:2: ( rule__LetBinding__NameAssignment_1 )
            {
             before(grammarAccess.getLetBindingAccess().getNameAssignment_1()); 
            // InternalSolverLanguageParser.g:5566:2: ( rule__LetBinding__NameAssignment_1 )
            // InternalSolverLanguageParser.g:5566:3: rule__LetBinding__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__LetBinding__NameAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getLetBindingAccess().getNameAssignment_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__2"
    // InternalSolverLanguageParser.g:5574:1: rule__LetBinding__Group__2 : rule__LetBinding__Group__2__Impl rule__LetBinding__Group__3 ;
    public final void rule__LetBinding__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5578:1: ( rule__LetBinding__Group__2__Impl rule__LetBinding__Group__3 )
            // InternalSolverLanguageParser.g:5579:2: rule__LetBinding__Group__2__Impl rule__LetBinding__Group__3
            {
            pushFollow(FOLLOW_12);
            rule__LetBinding__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LetBinding__Group__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__2__Impl"
    // InternalSolverLanguageParser.g:5586:1: rule__LetBinding__Group__2__Impl : ( EqualsSign ) ;
    public final void rule__LetBinding__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5590:1: ( ( EqualsSign ) )
            // InternalSolverLanguageParser.g:5591:1: ( EqualsSign )
            {
            // InternalSolverLanguageParser.g:5591:1: ( EqualsSign )
            // InternalSolverLanguageParser.g:5592:2: EqualsSign
            {
             before(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); 
            match(input,EqualsSign,FOLLOW_2); 
             after(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__3"
    // InternalSolverLanguageParser.g:5601:1: rule__LetBinding__Group__3 : rule__LetBinding__Group__3__Impl ;
    public final void rule__LetBinding__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5605:1: ( rule__LetBinding__Group__3__Impl )
            // InternalSolverLanguageParser.g:5606:2: rule__LetBinding__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LetBinding__Group__3__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LetBinding__Group__3__Impl"
    // InternalSolverLanguageParser.g:5612:1: rule__LetBinding__Group__3__Impl : ( ( rule__LetBinding__ValueAssignment_3 ) ) ;
    public final void rule__LetBinding__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5616:1: ( ( ( rule__LetBinding__ValueAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:5617:1: ( ( rule__LetBinding__ValueAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:5617:1: ( ( rule__LetBinding__ValueAssignment_3 ) )
            // InternalSolverLanguageParser.g:5618:2: ( rule__LetBinding__ValueAssignment_3 )
            {
             before(grammarAccess.getLetBindingAccess().getValueAssignment_3()); 
            // InternalSolverLanguageParser.g:5619:2: ( rule__LetBinding__ValueAssignment_3 )
            // InternalSolverLanguageParser.g:5619:3: rule__LetBinding__ValueAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__LetBinding__ValueAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getLetBindingAccess().getValueAssignment_3()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group__0"
    // InternalSolverLanguageParser.g:5628:1: rule__DisjunctiveExpression__Group__0 : rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 ;
    public final void rule__DisjunctiveExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5632:1: ( rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 )
            // InternalSolverLanguageParser.g:5633:2: rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1
            {
            pushFollow(FOLLOW_31);
            rule__DisjunctiveExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:5640:1: rule__DisjunctiveExpression__Group__0__Impl : ( ruleConjunctiveExpression ) ;
    public final void rule__DisjunctiveExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5644:1: ( ( ruleConjunctiveExpression ) )
            // InternalSolverLanguageParser.g:5645:1: ( ruleConjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:5645:1: ( ruleConjunctiveExpression )
            // InternalSolverLanguageParser.g:5646:2: ruleConjunctiveExpression
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleConjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group__1"
    // InternalSolverLanguageParser.g:5655:1: rule__DisjunctiveExpression__Group__1 : rule__DisjunctiveExpression__Group__1__Impl ;
    public final void rule__DisjunctiveExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5659:1: ( rule__DisjunctiveExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:5660:2: rule__DisjunctiveExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:5666:1: rule__DisjunctiveExpression__Group__1__Impl : ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) ;
    public final void rule__DisjunctiveExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5670:1: ( ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) )
            // InternalSolverLanguageParser.g:5671:1: ( ( rule__DisjunctiveExpression__Alternatives_1 )? )
            {
            // InternalSolverLanguageParser.g:5671:1: ( ( rule__DisjunctiveExpression__Alternatives_1 )? )
            // InternalSolverLanguageParser.g:5672:2: ( rule__DisjunctiveExpression__Alternatives_1 )?
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); 
            // InternalSolverLanguageParser.g:5673:2: ( rule__DisjunctiveExpression__Alternatives_1 )?
            int alt41=2;
            int LA41_0 = input.LA(1);

            if ( (LA41_0==HyphenMinusGreaterThanSign||LA41_0==Semicolon) ) {
                alt41=1;
            }
            switch (alt41) {
                case 1 :
                    // InternalSolverLanguageParser.g:5673:3: rule__DisjunctiveExpression__Alternatives_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__DisjunctiveExpression__Alternatives_1();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__0"
    // InternalSolverLanguageParser.g:5682:1: rule__DisjunctiveExpression__Group_1_0__0 : rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 ;
    public final void rule__DisjunctiveExpression__Group_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5686:1: ( rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 )
            // InternalSolverLanguageParser.g:5687:2: rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1
            {
            pushFollow(FOLLOW_32);
            rule__DisjunctiveExpression__Group_1_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_0__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__0__Impl"
    // InternalSolverLanguageParser.g:5694:1: rule__DisjunctiveExpression__Group_1_0__0__Impl : ( () ) ;
    public final void rule__DisjunctiveExpression__Group_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5698:1: ( ( () ) )
            // InternalSolverLanguageParser.g:5699:1: ( () )
            {
            // InternalSolverLanguageParser.g:5699:1: ( () )
            // InternalSolverLanguageParser.g:5700:2: ()
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); 
            // InternalSolverLanguageParser.g:5701:2: ()
            // InternalSolverLanguageParser.g:5701:3: 
            {
            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__1"
    // InternalSolverLanguageParser.g:5709:1: rule__DisjunctiveExpression__Group_1_0__1 : rule__DisjunctiveExpression__Group_1_0__1__Impl ;
    public final void rule__DisjunctiveExpression__Group_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5713:1: ( rule__DisjunctiveExpression__Group_1_0__1__Impl )
            // InternalSolverLanguageParser.g:5714:2: rule__DisjunctiveExpression__Group_1_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_0__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__1__Impl"
    // InternalSolverLanguageParser.g:5720:1: rule__DisjunctiveExpression__Group_1_0__1__Impl : ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) ;
    public final void rule__DisjunctiveExpression__Group_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5724:1: ( ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) )
            // InternalSolverLanguageParser.g:5725:1: ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) )
            {
            // InternalSolverLanguageParser.g:5725:1: ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) )
            // InternalSolverLanguageParser.g:5726:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* )
            {
            // InternalSolverLanguageParser.g:5726:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) )
            // InternalSolverLanguageParser.g:5727:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); 
            // InternalSolverLanguageParser.g:5728:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )
            // InternalSolverLanguageParser.g:5728:4: rule__DisjunctiveExpression__Group_1_0_1__0
            {
            pushFollow(FOLLOW_33);
            rule__DisjunctiveExpression__Group_1_0_1__0();

            state._fsp--;


            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); 

            }

            // InternalSolverLanguageParser.g:5731:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* )
            // InternalSolverLanguageParser.g:5732:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )*
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); 
            // InternalSolverLanguageParser.g:5733:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )*
            loop42:
            do {
                int alt42=2;
                int LA42_0 = input.LA(1);

                if ( (LA42_0==Semicolon) ) {
                    alt42=1;
                }


                switch (alt42) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:5733:4: rule__DisjunctiveExpression__Group_1_0_1__0
            	    {
            	    pushFollow(FOLLOW_33);
            	    rule__DisjunctiveExpression__Group_1_0_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop42;
                }
            } while (true);

             after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); 

            }


            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__0"
    // InternalSolverLanguageParser.g:5743:1: rule__DisjunctiveExpression__Group_1_0_1__0 : rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 ;
    public final void rule__DisjunctiveExpression__Group_1_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5747:1: ( rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 )
            // InternalSolverLanguageParser.g:5748:2: rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1
            {
            pushFollow(FOLLOW_12);
            rule__DisjunctiveExpression__Group_1_0_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_0_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__0__Impl"
    // InternalSolverLanguageParser.g:5755:1: rule__DisjunctiveExpression__Group_1_0_1__0__Impl : ( Semicolon ) ;
    public final void rule__DisjunctiveExpression__Group_1_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5759:1: ( ( Semicolon ) )
            // InternalSolverLanguageParser.g:5760:1: ( Semicolon )
            {
            // InternalSolverLanguageParser.g:5760:1: ( Semicolon )
            // InternalSolverLanguageParser.g:5761:2: Semicolon
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); 
            match(input,Semicolon,FOLLOW_2); 
             after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__1"
    // InternalSolverLanguageParser.g:5770:1: rule__DisjunctiveExpression__Group_1_0_1__1 : rule__DisjunctiveExpression__Group_1_0_1__1__Impl ;
    public final void rule__DisjunctiveExpression__Group_1_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5774:1: ( rule__DisjunctiveExpression__Group_1_0_1__1__Impl )
            // InternalSolverLanguageParser.g:5775:2: rule__DisjunctiveExpression__Group_1_0_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_0_1__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__1__Impl"
    // InternalSolverLanguageParser.g:5781:1: rule__DisjunctiveExpression__Group_1_0_1__1__Impl : ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) ;
    public final void rule__DisjunctiveExpression__Group_1_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5785:1: ( ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) )
            // InternalSolverLanguageParser.g:5786:1: ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) )
            {
            // InternalSolverLanguageParser.g:5786:1: ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) )
            // InternalSolverLanguageParser.g:5787:2: ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 )
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); 
            // InternalSolverLanguageParser.g:5788:2: ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 )
            // InternalSolverLanguageParser.g:5788:3: rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1();

            state._fsp--;


            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__0"
    // InternalSolverLanguageParser.g:5797:1: rule__DisjunctiveExpression__Group_1_1__0 : rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 ;
    public final void rule__DisjunctiveExpression__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5801:1: ( rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 )
            // InternalSolverLanguageParser.g:5802:2: rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1
            {
            pushFollow(FOLLOW_31);
            rule__DisjunctiveExpression__Group_1_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__0__Impl"
    // InternalSolverLanguageParser.g:5809:1: rule__DisjunctiveExpression__Group_1_1__0__Impl : ( () ) ;
    public final void rule__DisjunctiveExpression__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5813:1: ( ( () ) )
            // InternalSolverLanguageParser.g:5814:1: ( () )
            {
            // InternalSolverLanguageParser.g:5814:1: ( () )
            // InternalSolverLanguageParser.g:5815:2: ()
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); 
            // InternalSolverLanguageParser.g:5816:2: ()
            // InternalSolverLanguageParser.g:5816:3: 
            {
            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__1"
    // InternalSolverLanguageParser.g:5824:1: rule__DisjunctiveExpression__Group_1_1__1 : rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 ;
    public final void rule__DisjunctiveExpression__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5828:1: ( rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 )
            // InternalSolverLanguageParser.g:5829:2: rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2
            {
            pushFollow(FOLLOW_12);
            rule__DisjunctiveExpression__Group_1_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__1__Impl"
    // InternalSolverLanguageParser.g:5836:1: rule__DisjunctiveExpression__Group_1_1__1__Impl : ( HyphenMinusGreaterThanSign ) ;
    public final void rule__DisjunctiveExpression__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5840:1: ( ( HyphenMinusGreaterThanSign ) )
            // InternalSolverLanguageParser.g:5841:1: ( HyphenMinusGreaterThanSign )
            {
            // InternalSolverLanguageParser.g:5841:1: ( HyphenMinusGreaterThanSign )
            // InternalSolverLanguageParser.g:5842:2: HyphenMinusGreaterThanSign
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); 
            match(input,HyphenMinusGreaterThanSign,FOLLOW_2); 
             after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__2"
    // InternalSolverLanguageParser.g:5851:1: rule__DisjunctiveExpression__Group_1_1__2 : rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 ;
    public final void rule__DisjunctiveExpression__Group_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5855:1: ( rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 )
            // InternalSolverLanguageParser.g:5856:2: rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3
            {
            pushFollow(FOLLOW_32);
            rule__DisjunctiveExpression__Group_1_1__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1__3();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__2__Impl"
    // InternalSolverLanguageParser.g:5863:1: rule__DisjunctiveExpression__Group_1_1__2__Impl : ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) ;
    public final void rule__DisjunctiveExpression__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5867:1: ( ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) )
            // InternalSolverLanguageParser.g:5868:1: ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) )
            {
            // InternalSolverLanguageParser.g:5868:1: ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) )
            // InternalSolverLanguageParser.g:5869:2: ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 )
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); 
            // InternalSolverLanguageParser.g:5870:2: ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 )
            // InternalSolverLanguageParser.g:5870:3: rule__DisjunctiveExpression__BodyAssignment_1_1_2
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__BodyAssignment_1_1_2();

            state._fsp--;


            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__3"
    // InternalSolverLanguageParser.g:5878:1: rule__DisjunctiveExpression__Group_1_1__3 : rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 ;
    public final void rule__DisjunctiveExpression__Group_1_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5882:1: ( rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 )
            // InternalSolverLanguageParser.g:5883:2: rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4
            {
            pushFollow(FOLLOW_32);
            rule__DisjunctiveExpression__Group_1_1__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1__4();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__3__Impl"
    // InternalSolverLanguageParser.g:5890:1: rule__DisjunctiveExpression__Group_1_1__3__Impl : ( () ) ;
    public final void rule__DisjunctiveExpression__Group_1_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5894:1: ( ( () ) )
            // InternalSolverLanguageParser.g:5895:1: ( () )
            {
            // InternalSolverLanguageParser.g:5895:1: ( () )
            // InternalSolverLanguageParser.g:5896:2: ()
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); 
            // InternalSolverLanguageParser.g:5897:2: ()
            // InternalSolverLanguageParser.g:5897:3: 
            {
            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__4"
    // InternalSolverLanguageParser.g:5905:1: rule__DisjunctiveExpression__Group_1_1__4 : rule__DisjunctiveExpression__Group_1_1__4__Impl ;
    public final void rule__DisjunctiveExpression__Group_1_1__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5909:1: ( rule__DisjunctiveExpression__Group_1_1__4__Impl )
            // InternalSolverLanguageParser.g:5910:2: rule__DisjunctiveExpression__Group_1_1__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1__4__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__4__Impl"
    // InternalSolverLanguageParser.g:5916:1: rule__DisjunctiveExpression__Group_1_1__4__Impl : ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) ;
    public final void rule__DisjunctiveExpression__Group_1_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5920:1: ( ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) )
            // InternalSolverLanguageParser.g:5921:1: ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* )
            {
            // InternalSolverLanguageParser.g:5921:1: ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* )
            // InternalSolverLanguageParser.g:5922:2: ( rule__DisjunctiveExpression__Group_1_1_4__0 )*
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); 
            // InternalSolverLanguageParser.g:5923:2: ( rule__DisjunctiveExpression__Group_1_1_4__0 )*
            loop43:
            do {
                int alt43=2;
                int LA43_0 = input.LA(1);

                if ( (LA43_0==Semicolon) ) {
                    alt43=1;
                }


                switch (alt43) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:5923:3: rule__DisjunctiveExpression__Group_1_1_4__0
            	    {
            	    pushFollow(FOLLOW_33);
            	    rule__DisjunctiveExpression__Group_1_1_4__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop43;
                }
            } while (true);

             after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__0"
    // InternalSolverLanguageParser.g:5932:1: rule__DisjunctiveExpression__Group_1_1_4__0 : rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 ;
    public final void rule__DisjunctiveExpression__Group_1_1_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5936:1: ( rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 )
            // InternalSolverLanguageParser.g:5937:2: rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1
            {
            pushFollow(FOLLOW_12);
            rule__DisjunctiveExpression__Group_1_1_4__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1_4__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__0__Impl"
    // InternalSolverLanguageParser.g:5944:1: rule__DisjunctiveExpression__Group_1_1_4__0__Impl : ( Semicolon ) ;
    public final void rule__DisjunctiveExpression__Group_1_1_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5948:1: ( ( Semicolon ) )
            // InternalSolverLanguageParser.g:5949:1: ( Semicolon )
            {
            // InternalSolverLanguageParser.g:5949:1: ( Semicolon )
            // InternalSolverLanguageParser.g:5950:2: Semicolon
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); 
            match(input,Semicolon,FOLLOW_2); 
             after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__1"
    // InternalSolverLanguageParser.g:5959:1: rule__DisjunctiveExpression__Group_1_1_4__1 : rule__DisjunctiveExpression__Group_1_1_4__1__Impl ;
    public final void rule__DisjunctiveExpression__Group_1_1_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5963:1: ( rule__DisjunctiveExpression__Group_1_1_4__1__Impl )
            // InternalSolverLanguageParser.g:5964:2: rule__DisjunctiveExpression__Group_1_1_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__Group_1_1_4__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__1__Impl"
    // InternalSolverLanguageParser.g:5970:1: rule__DisjunctiveExpression__Group_1_1_4__1__Impl : ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) ;
    public final void rule__DisjunctiveExpression__Group_1_1_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:5974:1: ( ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) )
            // InternalSolverLanguageParser.g:5975:1: ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) )
            {
            // InternalSolverLanguageParser.g:5975:1: ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) )
            // InternalSolverLanguageParser.g:5976:2: ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 )
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); 
            // InternalSolverLanguageParser.g:5977:2: ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 )
            // InternalSolverLanguageParser.g:5977:3: rule__DisjunctiveExpression__CasesAssignment_1_1_4_1
            {
            pushFollow(FOLLOW_2);
            rule__DisjunctiveExpression__CasesAssignment_1_1_4_1();

            state._fsp--;


            }

             after(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Case__Group__0"
    // InternalSolverLanguageParser.g:5986: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 {
            // InternalSolverLanguageParser.g:5990:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 )
            // InternalSolverLanguageParser.g:5991:2: rule__Case__Group__0__Impl rule__Case__Group__1
            {
            pushFollow(FOLLOW_34);
            rule__Case__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Case__Group__1();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:5998:1: rule__Case__Group__0__Impl : ( ( rule__Case__ConditionAssignment_0 ) ) ;
    public final void rule__Case__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6002:1: ( ( ( rule__Case__ConditionAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:6003:1: ( ( rule__Case__ConditionAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:6003:1: ( ( rule__Case__ConditionAssignment_0 ) )
            // InternalSolverLanguageParser.g:6004:2: ( rule__Case__ConditionAssignment_0 )
            {
             before(grammarAccess.getCaseAccess().getConditionAssignment_0()); 
            // InternalSolverLanguageParser.g:6005:2: ( rule__Case__ConditionAssignment_0 )
            // InternalSolverLanguageParser.g:6005:3: rule__Case__ConditionAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__Case__ConditionAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getCaseAccess().getConditionAssignment_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"
    // InternalSolverLanguageParser.g:6013: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 {
            // InternalSolverLanguageParser.g:6017:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 )
            // InternalSolverLanguageParser.g:6018:2: rule__Case__Group__1__Impl rule__Case__Group__2
            {
            pushFollow(FOLLOW_12);
            rule__Case__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Case__Group__2();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:6025:1: rule__Case__Group__1__Impl : ( HyphenMinusGreaterThanSign ) ;
    public final void rule__Case__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6029:1: ( ( HyphenMinusGreaterThanSign ) )
            // InternalSolverLanguageParser.g:6030:1: ( HyphenMinusGreaterThanSign )
            {
            // InternalSolverLanguageParser.g:6030:1: ( HyphenMinusGreaterThanSign )
            // InternalSolverLanguageParser.g:6031:2: HyphenMinusGreaterThanSign
            {
             before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); 
            match(input,HyphenMinusGreaterThanSign,FOLLOW_2); 
             after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_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"
    // InternalSolverLanguageParser.g:6040:1: rule__Case__Group__2 : rule__Case__Group__2__Impl ;
    public final void rule__Case__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6044:1: ( rule__Case__Group__2__Impl )
            // InternalSolverLanguageParser.g:6045:2: rule__Case__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Case__Group__2__Impl();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:6051:1: rule__Case__Group__2__Impl : ( ( rule__Case__BodyAssignment_2 ) ) ;
    public final void rule__Case__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6055:1: ( ( ( rule__Case__BodyAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:6056:1: ( ( rule__Case__BodyAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:6056:1: ( ( rule__Case__BodyAssignment_2 ) )
            // InternalSolverLanguageParser.g:6057:2: ( rule__Case__BodyAssignment_2 )
            {
             before(grammarAccess.getCaseAccess().getBodyAssignment_2()); 
            // InternalSolverLanguageParser.g:6058:2: ( rule__Case__BodyAssignment_2 )
            // InternalSolverLanguageParser.g:6058:3: rule__Case__BodyAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__Case__BodyAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getCaseAccess().getBodyAssignment_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group__0"
    // InternalSolverLanguageParser.g:6067:1: rule__ConjunctiveExpression__Group__0 : rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 ;
    public final void rule__ConjunctiveExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6071:1: ( rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 )
            // InternalSolverLanguageParser.g:6072:2: rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1
            {
            pushFollow(FOLLOW_35);
            rule__ConjunctiveExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:6079:1: rule__ConjunctiveExpression__Group__0__Impl : ( ruleComparisonExpression ) ;
    public final void rule__ConjunctiveExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6083:1: ( ( ruleComparisonExpression ) )
            // InternalSolverLanguageParser.g:6084:1: ( ruleComparisonExpression )
            {
            // InternalSolverLanguageParser.g:6084:1: ( ruleComparisonExpression )
            // InternalSolverLanguageParser.g:6085:2: ruleComparisonExpression
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleComparisonExpression();

            state._fsp--;

             after(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group__1"
    // InternalSolverLanguageParser.g:6094:1: rule__ConjunctiveExpression__Group__1 : rule__ConjunctiveExpression__Group__1__Impl ;
    public final void rule__ConjunctiveExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6098:1: ( rule__ConjunctiveExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:6099:2: rule__ConjunctiveExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:6105:1: rule__ConjunctiveExpression__Group__1__Impl : ( ( rule__ConjunctiveExpression__Group_1__0 )? ) ;
    public final void rule__ConjunctiveExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6109:1: ( ( ( rule__ConjunctiveExpression__Group_1__0 )? ) )
            // InternalSolverLanguageParser.g:6110:1: ( ( rule__ConjunctiveExpression__Group_1__0 )? )
            {
            // InternalSolverLanguageParser.g:6110:1: ( ( rule__ConjunctiveExpression__Group_1__0 )? )
            // InternalSolverLanguageParser.g:6111:2: ( rule__ConjunctiveExpression__Group_1__0 )?
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:6112:2: ( rule__ConjunctiveExpression__Group_1__0 )?
            int alt44=2;
            int LA44_0 = input.LA(1);

            if ( (LA44_0==Comma) ) {
                alt44=1;
            }
            switch (alt44) {
                case 1 :
                    // InternalSolverLanguageParser.g:6112:3: rule__ConjunctiveExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ConjunctiveExpression__Group_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6121:1: rule__ConjunctiveExpression__Group_1__0 : rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 ;
    public final void rule__ConjunctiveExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6125:1: ( rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6126:2: rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1
            {
            pushFollow(FOLLOW_35);
            rule__ConjunctiveExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6133:1: rule__ConjunctiveExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__ConjunctiveExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6137:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6138:1: ( () )
            {
            // InternalSolverLanguageParser.g:6138:1: ( () )
            // InternalSolverLanguageParser.g:6139:2: ()
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); 
            // InternalSolverLanguageParser.g:6140:2: ()
            // InternalSolverLanguageParser.g:6140:3: 
            {
            }

             after(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6148:1: rule__ConjunctiveExpression__Group_1__1 : rule__ConjunctiveExpression__Group_1__1__Impl ;
    public final void rule__ConjunctiveExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6152:1: ( rule__ConjunctiveExpression__Group_1__1__Impl )
            // InternalSolverLanguageParser.g:6153:2: rule__ConjunctiveExpression__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group_1__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6159:1: rule__ConjunctiveExpression__Group_1__1__Impl : ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) ;
    public final void rule__ConjunctiveExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6163:1: ( ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) )
            // InternalSolverLanguageParser.g:6164:1: ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) )
            {
            // InternalSolverLanguageParser.g:6164:1: ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) )
            // InternalSolverLanguageParser.g:6165:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* )
            {
            // InternalSolverLanguageParser.g:6165:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 ) )
            // InternalSolverLanguageParser.g:6166:3: ( rule__ConjunctiveExpression__Group_1_1__0 )
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); 
            // InternalSolverLanguageParser.g:6167:3: ( rule__ConjunctiveExpression__Group_1_1__0 )
            // InternalSolverLanguageParser.g:6167:4: rule__ConjunctiveExpression__Group_1_1__0
            {
            pushFollow(FOLLOW_29);
            rule__ConjunctiveExpression__Group_1_1__0();

            state._fsp--;


            }

             after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); 

            }

            // InternalSolverLanguageParser.g:6170:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 )* )
            // InternalSolverLanguageParser.g:6171:3: ( rule__ConjunctiveExpression__Group_1_1__0 )*
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); 
            // InternalSolverLanguageParser.g:6172:3: ( rule__ConjunctiveExpression__Group_1_1__0 )*
            loop45:
            do {
                int alt45=2;
                int LA45_0 = input.LA(1);

                if ( (LA45_0==Comma) ) {
                    alt45=1;
                }


                switch (alt45) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:6172:4: rule__ConjunctiveExpression__Group_1_1__0
            	    {
            	    pushFollow(FOLLOW_29);
            	    rule__ConjunctiveExpression__Group_1_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } while (true);

             after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); 

            }


            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__0"
    // InternalSolverLanguageParser.g:6182:1: rule__ConjunctiveExpression__Group_1_1__0 : rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 ;
    public final void rule__ConjunctiveExpression__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6186:1: ( rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 )
            // InternalSolverLanguageParser.g:6187:2: rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1
            {
            pushFollow(FOLLOW_12);
            rule__ConjunctiveExpression__Group_1_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group_1_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__0__Impl"
    // InternalSolverLanguageParser.g:6194:1: rule__ConjunctiveExpression__Group_1_1__0__Impl : ( Comma ) ;
    public final void rule__ConjunctiveExpression__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6198:1: ( ( Comma ) )
            // InternalSolverLanguageParser.g:6199:1: ( Comma )
            {
            // InternalSolverLanguageParser.g:6199:1: ( Comma )
            // InternalSolverLanguageParser.g:6200:2: Comma
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); 
            match(input,Comma,FOLLOW_2); 
             after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__1"
    // InternalSolverLanguageParser.g:6209:1: rule__ConjunctiveExpression__Group_1_1__1 : rule__ConjunctiveExpression__Group_1_1__1__Impl ;
    public final void rule__ConjunctiveExpression__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6213:1: ( rule__ConjunctiveExpression__Group_1_1__1__Impl )
            // InternalSolverLanguageParser.g:6214:2: rule__ConjunctiveExpression__Group_1_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__Group_1_1__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__1__Impl"
    // InternalSolverLanguageParser.g:6220:1: rule__ConjunctiveExpression__Group_1_1__1__Impl : ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) ;
    public final void rule__ConjunctiveExpression__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6224:1: ( ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) )
            // InternalSolverLanguageParser.g:6225:1: ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) )
            {
            // InternalSolverLanguageParser.g:6225:1: ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) )
            // InternalSolverLanguageParser.g:6226:2: ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 )
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); 
            // InternalSolverLanguageParser.g:6227:2: ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 )
            // InternalSolverLanguageParser.g:6227:3: rule__ConjunctiveExpression__ChildrenAssignment_1_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ConjunctiveExpression__ChildrenAssignment_1_1_1();

            state._fsp--;


            }

             after(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group__0"
    // InternalSolverLanguageParser.g:6236:1: rule__ComparisonExpression__Group__0 : rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 ;
    public final void rule__ComparisonExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6240:1: ( rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 )
            // InternalSolverLanguageParser.g:6241:2: rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1
            {
            pushFollow(FOLLOW_36);
            rule__ComparisonExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:6248:1: rule__ComparisonExpression__Group__0__Impl : ( ruleAdditiveExpression ) ;
    public final void rule__ComparisonExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6252:1: ( ( ruleAdditiveExpression ) )
            // InternalSolverLanguageParser.g:6253:1: ( ruleAdditiveExpression )
            {
            // InternalSolverLanguageParser.g:6253:1: ( ruleAdditiveExpression )
            // InternalSolverLanguageParser.g:6254:2: ruleAdditiveExpression
            {
             before(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleAdditiveExpression();

            state._fsp--;

             after(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group__1"
    // InternalSolverLanguageParser.g:6263:1: rule__ComparisonExpression__Group__1 : rule__ComparisonExpression__Group__1__Impl ;
    public final void rule__ComparisonExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6267:1: ( rule__ComparisonExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:6268:2: rule__ComparisonExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__Group__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:6274:1: rule__ComparisonExpression__Group__1__Impl : ( ( rule__ComparisonExpression__Group_1__0 )? ) ;
    public final void rule__ComparisonExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6278:1: ( ( ( rule__ComparisonExpression__Group_1__0 )? ) )
            // InternalSolverLanguageParser.g:6279:1: ( ( rule__ComparisonExpression__Group_1__0 )? )
            {
            // InternalSolverLanguageParser.g:6279:1: ( ( rule__ComparisonExpression__Group_1__0 )? )
            // InternalSolverLanguageParser.g:6280:2: ( rule__ComparisonExpression__Group_1__0 )?
            {
             before(grammarAccess.getComparisonExpressionAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:6281:2: ( rule__ComparisonExpression__Group_1__0 )?
            int alt46=2;
            int LA46_0 = input.LA(1);

            if ( (LA46_0==ExclamationMarkEqualsSign||(LA46_0>=LessThanSignEqualsSign && LA46_0<=EqualsSignEqualsSign)||LA46_0==GreaterThanSignEqualsSign||LA46_0==In||LA46_0==LessThanSign||LA46_0==GreaterThanSign) ) {
                alt46=1;
            }
            switch (alt46) {
                case 1 :
                    // InternalSolverLanguageParser.g:6281:3: rule__ComparisonExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ComparisonExpression__Group_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getComparisonExpressionAccess().getGroup_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6290:1: rule__ComparisonExpression__Group_1__0 : rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 ;
    public final void rule__ComparisonExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6294:1: ( rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6295:2: rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1
            {
            pushFollow(FOLLOW_36);
            rule__ComparisonExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__Group_1__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6302:1: rule__ComparisonExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__ComparisonExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6306:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6307:1: ( () )
            {
            // InternalSolverLanguageParser.g:6307:1: ( () )
            // InternalSolverLanguageParser.g:6308:2: ()
            {
             before(grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0()); 
            // InternalSolverLanguageParser.g:6309:2: ()
            // InternalSolverLanguageParser.g:6309:3: 
            {
            }

             after(grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6317:1: rule__ComparisonExpression__Group_1__1 : rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 ;
    public final void rule__ComparisonExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6321:1: ( rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 )
            // InternalSolverLanguageParser.g:6322:2: rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2
            {
            pushFollow(FOLLOW_12);
            rule__ComparisonExpression__Group_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__Group_1__2();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6329:1: rule__ComparisonExpression__Group_1__1__Impl : ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) ;
    public final void rule__ComparisonExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6333:1: ( ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) )
            // InternalSolverLanguageParser.g:6334:1: ( ( rule__ComparisonExpression__OpAssignment_1_1 ) )
            {
            // InternalSolverLanguageParser.g:6334:1: ( ( rule__ComparisonExpression__OpAssignment_1_1 ) )
            // InternalSolverLanguageParser.g:6335:2: ( rule__ComparisonExpression__OpAssignment_1_1 )
            {
             before(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); 
            // InternalSolverLanguageParser.g:6336:2: ( rule__ComparisonExpression__OpAssignment_1_1 )
            // InternalSolverLanguageParser.g:6336:3: rule__ComparisonExpression__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__OpAssignment_1_1();

            state._fsp--;


            }

             after(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group_1__2"
    // InternalSolverLanguageParser.g:6344:1: rule__ComparisonExpression__Group_1__2 : rule__ComparisonExpression__Group_1__2__Impl ;
    public final void rule__ComparisonExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6348:1: ( rule__ComparisonExpression__Group_1__2__Impl )
            // InternalSolverLanguageParser.g:6349:2: rule__ComparisonExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__Group_1__2__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ComparisonExpression__Group_1__2__Impl"
    // InternalSolverLanguageParser.g:6355:1: rule__ComparisonExpression__Group_1__2__Impl : ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) ;
    public final void rule__ComparisonExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6359:1: ( ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) )
            // InternalSolverLanguageParser.g:6360:1: ( ( rule__ComparisonExpression__RightAssignment_1_2 ) )
            {
            // InternalSolverLanguageParser.g:6360:1: ( ( rule__ComparisonExpression__RightAssignment_1_2 ) )
            // InternalSolverLanguageParser.g:6361:2: ( rule__ComparisonExpression__RightAssignment_1_2 )
            {
             before(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); 
            // InternalSolverLanguageParser.g:6362:2: ( rule__ComparisonExpression__RightAssignment_1_2 )
            // InternalSolverLanguageParser.g:6362:3: rule__ComparisonExpression__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ComparisonExpression__RightAssignment_1_2();

            state._fsp--;


            }

             after(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AdditiveExpression__Group__0"
    // InternalSolverLanguageParser.g:6371:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ;
    public final void rule__AdditiveExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6375:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 )
            // InternalSolverLanguageParser.g:6376:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1
            {
            pushFollow(FOLLOW_37);
            rule__AdditiveExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__Group__1();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AdditiveExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:6383:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ;
    public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6387:1: ( ( ruleMultiplicativeExpression ) )
            // InternalSolverLanguageParser.g:6388:1: ( ruleMultiplicativeExpression )
            {
            // InternalSolverLanguageParser.g:6388:1: ( ruleMultiplicativeExpression )
            // InternalSolverLanguageParser.g:6389:2: ruleMultiplicativeExpression
            {
             before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleMultiplicativeExpression();

            state._fsp--;

             after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); 

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AdditiveExpression__Group__1"
    // InternalSolverLanguageParser.g:6398:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ;
    public final void rule__AdditiveExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6402:1: ( rule__AdditiveExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:6403:2: rule__AdditiveExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__Group__1__Impl();

            state._fsp--;


            }

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

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group__1"


    // $ANTLR start "rule__AdditiveExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:6409:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ;
    public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6413:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) )
            // InternalSolverLanguageParser.g:6414:1: ( ( rule__AdditiveExpression__Group_1__0 )* )
            {
            // InternalSolverLanguageParser.g:6414:1: ( ( rule__AdditiveExpression__Group_1__0 )* )
            // InternalSolverLanguageParser.g:6415:2: ( rule__AdditiveExpression__Group_1__0 )*
            {
             before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:6416:2: ( rule__AdditiveExpression__Group_1__0 )*
            loop47:
            do {
                int alt47=2;
                int LA47_0 = input.LA(1);

                if ( (LA47_0==PlusSign||LA47_0==HyphenMinus) ) {
                    alt47=1;
                }


                switch (alt47) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:6416:3: rule__AdditiveExpression__Group_1__0
            	    {
            	    pushFollow(FOLLOW_38);
            	    rule__AdditiveExpression__Group_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop47;
                }
            } while (true);

             after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group__1__Impl"


    // $ANTLR start "rule__AdditiveExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6425:1: rule__AdditiveExpression__Group_1__0 : rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ;
    public final void rule__AdditiveExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6429:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6430:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1
            {
            pushFollow(FOLLOW_37);
            rule__AdditiveExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__Group_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group_1__0"


    // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6437:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6441:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6442:1: ( () )
            {
            // InternalSolverLanguageParser.g:6442:1: ( () )
            // InternalSolverLanguageParser.g:6443:2: ()
            {
             before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); 
            // InternalSolverLanguageParser.g:6444:2: ()
            // InternalSolverLanguageParser.g:6444:3: 
            {
            }

             after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl"


    // $ANTLR start "rule__AdditiveExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6452:1: rule__AdditiveExpression__Group_1__1 : rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ;
    public final void rule__AdditiveExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6456:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 )
            // InternalSolverLanguageParser.g:6457:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2
            {
            pushFollow(FOLLOW_12);
            rule__AdditiveExpression__Group_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__Group_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group_1__1"


    // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6464:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) ;
    public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6468:1: ( ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) )
            // InternalSolverLanguageParser.g:6469:1: ( ( rule__AdditiveExpression__OpAssignment_1_1 ) )
            {
            // InternalSolverLanguageParser.g:6469:1: ( ( rule__AdditiveExpression__OpAssignment_1_1 ) )
            // InternalSolverLanguageParser.g:6470:2: ( rule__AdditiveExpression__OpAssignment_1_1 )
            {
             before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); 
            // InternalSolverLanguageParser.g:6471:2: ( rule__AdditiveExpression__OpAssignment_1_1 )
            // InternalSolverLanguageParser.g:6471:3: rule__AdditiveExpression__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__OpAssignment_1_1();

            state._fsp--;


            }

             after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl"


    // $ANTLR start "rule__AdditiveExpression__Group_1__2"
    // InternalSolverLanguageParser.g:6479:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ;
    public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6483:1: ( rule__AdditiveExpression__Group_1__2__Impl )
            // InternalSolverLanguageParser.g:6484:2: rule__AdditiveExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__Group_1__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group_1__2"


    // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl"
    // InternalSolverLanguageParser.g:6490:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ;
    public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6494:1: ( ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) )
            // InternalSolverLanguageParser.g:6495:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) )
            {
            // InternalSolverLanguageParser.g:6495:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) )
            // InternalSolverLanguageParser.g:6496:2: ( rule__AdditiveExpression__RightAssignment_1_2 )
            {
             before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); 
            // InternalSolverLanguageParser.g:6497:2: ( rule__AdditiveExpression__RightAssignment_1_2 )
            // InternalSolverLanguageParser.g:6497:3: rule__AdditiveExpression__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__AdditiveExpression__RightAssignment_1_2();

            state._fsp--;


            }

             after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl"


    // $ANTLR start "rule__MultiplicativeExpression__Group__0"
    // InternalSolverLanguageParser.g:6506:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ;
    public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6510:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 )
            // InternalSolverLanguageParser.g:6511:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1
            {
            pushFollow(FOLLOW_39);
            rule__MultiplicativeExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group__0"


    // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:6518:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleExponentialExpression ) ;
    public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6522:1: ( ( ruleExponentialExpression ) )
            // InternalSolverLanguageParser.g:6523:1: ( ruleExponentialExpression )
            {
            // InternalSolverLanguageParser.g:6523:1: ( ruleExponentialExpression )
            // InternalSolverLanguageParser.g:6524:2: ruleExponentialExpression
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleExponentialExpression();

            state._fsp--;

             after(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl"


    // $ANTLR start "rule__MultiplicativeExpression__Group__1"
    // InternalSolverLanguageParser.g:6533:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ;
    public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6537:1: ( rule__MultiplicativeExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:6538:2: rule__MultiplicativeExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group__1"


    // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:6544:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ;
    public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6548:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) )
            // InternalSolverLanguageParser.g:6549:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* )
            {
            // InternalSolverLanguageParser.g:6549:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* )
            // InternalSolverLanguageParser.g:6550:2: ( rule__MultiplicativeExpression__Group_1__0 )*
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:6551:2: ( rule__MultiplicativeExpression__Group_1__0 )*
            loop48:
            do {
                int alt48=2;
                int LA48_0 = input.LA(1);

                if ( (LA48_0==Asterisk||LA48_0==Solidus) ) {
                    alt48=1;
                }


                switch (alt48) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:6551:3: rule__MultiplicativeExpression__Group_1__0
            	    {
            	    pushFollow(FOLLOW_40);
            	    rule__MultiplicativeExpression__Group_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop48;
                }
            } while (true);

             after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl"


    // $ANTLR start "rule__MultiplicativeExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6560:1: rule__MultiplicativeExpression__Group_1__0 : rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ;
    public final void rule__MultiplicativeExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6564:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6565:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1
            {
            pushFollow(FOLLOW_39);
            rule__MultiplicativeExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__Group_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group_1__0"


    // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6572:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6576:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6577:1: ( () )
            {
            // InternalSolverLanguageParser.g:6577:1: ( () )
            // InternalSolverLanguageParser.g:6578:2: ()
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); 
            // InternalSolverLanguageParser.g:6579:2: ()
            // InternalSolverLanguageParser.g:6579:3: 
            {
            }

             after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl"


    // $ANTLR start "rule__MultiplicativeExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6587:1: rule__MultiplicativeExpression__Group_1__1 : rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ;
    public final void rule__MultiplicativeExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6591:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 )
            // InternalSolverLanguageParser.g:6592:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2
            {
            pushFollow(FOLLOW_12);
            rule__MultiplicativeExpression__Group_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__Group_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group_1__1"


    // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6599:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) ;
    public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6603:1: ( ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) )
            // InternalSolverLanguageParser.g:6604:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) )
            {
            // InternalSolverLanguageParser.g:6604:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) )
            // InternalSolverLanguageParser.g:6605:2: ( rule__MultiplicativeExpression__OpAssignment_1_1 )
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); 
            // InternalSolverLanguageParser.g:6606:2: ( rule__MultiplicativeExpression__OpAssignment_1_1 )
            // InternalSolverLanguageParser.g:6606:3: rule__MultiplicativeExpression__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__OpAssignment_1_1();

            state._fsp--;


            }

             after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl"


    // $ANTLR start "rule__MultiplicativeExpression__Group_1__2"
    // InternalSolverLanguageParser.g:6614:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ;
    public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6618:1: ( rule__MultiplicativeExpression__Group_1__2__Impl )
            // InternalSolverLanguageParser.g:6619:2: rule__MultiplicativeExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__Group_1__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group_1__2"


    // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl"
    // InternalSolverLanguageParser.g:6625:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ;
    public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6629:1: ( ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) )
            // InternalSolverLanguageParser.g:6630:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) )
            {
            // InternalSolverLanguageParser.g:6630:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) )
            // InternalSolverLanguageParser.g:6631:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 )
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); 
            // InternalSolverLanguageParser.g:6632:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 )
            // InternalSolverLanguageParser.g:6632:3: rule__MultiplicativeExpression__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicativeExpression__RightAssignment_1_2();

            state._fsp--;


            }

             after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl"


    // $ANTLR start "rule__ExponentialExpression__Group__0"
    // InternalSolverLanguageParser.g:6641:1: rule__ExponentialExpression__Group__0 : rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 ;
    public final void rule__ExponentialExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6645:1: ( rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 )
            // InternalSolverLanguageParser.g:6646:2: rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1
            {
            pushFollow(FOLLOW_41);
            rule__ExponentialExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group__0"


    // $ANTLR start "rule__ExponentialExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:6653:1: rule__ExponentialExpression__Group__0__Impl : ( ruleCastExpression ) ;
    public final void rule__ExponentialExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6657:1: ( ( ruleCastExpression ) )
            // InternalSolverLanguageParser.g:6658:1: ( ruleCastExpression )
            {
            // InternalSolverLanguageParser.g:6658:1: ( ruleCastExpression )
            // InternalSolverLanguageParser.g:6659:2: ruleCastExpression
            {
             before(grammarAccess.getExponentialExpressionAccess().getCastExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleCastExpression();

            state._fsp--;

             after(grammarAccess.getExponentialExpressionAccess().getCastExpressionParserRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group__0__Impl"


    // $ANTLR start "rule__ExponentialExpression__Group__1"
    // InternalSolverLanguageParser.g:6668:1: rule__ExponentialExpression__Group__1 : rule__ExponentialExpression__Group__1__Impl ;
    public final void rule__ExponentialExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6672:1: ( rule__ExponentialExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:6673:2: rule__ExponentialExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group__1"


    // $ANTLR start "rule__ExponentialExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:6679:1: rule__ExponentialExpression__Group__1__Impl : ( ( rule__ExponentialExpression__Group_1__0 )? ) ;
    public final void rule__ExponentialExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6683:1: ( ( ( rule__ExponentialExpression__Group_1__0 )? ) )
            // InternalSolverLanguageParser.g:6684:1: ( ( rule__ExponentialExpression__Group_1__0 )? )
            {
            // InternalSolverLanguageParser.g:6684:1: ( ( rule__ExponentialExpression__Group_1__0 )? )
            // InternalSolverLanguageParser.g:6685:2: ( rule__ExponentialExpression__Group_1__0 )?
            {
             before(grammarAccess.getExponentialExpressionAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:6686:2: ( rule__ExponentialExpression__Group_1__0 )?
            int alt49=2;
            int LA49_0 = input.LA(1);

            if ( (LA49_0==CircumflexAccent) ) {
                alt49=1;
            }
            switch (alt49) {
                case 1 :
                    // InternalSolverLanguageParser.g:6686:3: rule__ExponentialExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ExponentialExpression__Group_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getExponentialExpressionAccess().getGroup_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group__1__Impl"


    // $ANTLR start "rule__ExponentialExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6695:1: rule__ExponentialExpression__Group_1__0 : rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 ;
    public final void rule__ExponentialExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6699:1: ( rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6700:2: rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1
            {
            pushFollow(FOLLOW_41);
            rule__ExponentialExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__Group_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group_1__0"


    // $ANTLR start "rule__ExponentialExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6707:1: rule__ExponentialExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__ExponentialExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6711:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6712:1: ( () )
            {
            // InternalSolverLanguageParser.g:6712:1: ( () )
            // InternalSolverLanguageParser.g:6713:2: ()
            {
             before(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); 
            // InternalSolverLanguageParser.g:6714:2: ()
            // InternalSolverLanguageParser.g:6714:3: 
            {
            }

             after(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group_1__0__Impl"


    // $ANTLR start "rule__ExponentialExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6722:1: rule__ExponentialExpression__Group_1__1 : rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 ;
    public final void rule__ExponentialExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6726:1: ( rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 )
            // InternalSolverLanguageParser.g:6727:2: rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2
            {
            pushFollow(FOLLOW_12);
            rule__ExponentialExpression__Group_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__Group_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group_1__1"


    // $ANTLR start "rule__ExponentialExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6734:1: rule__ExponentialExpression__Group_1__1__Impl : ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) ;
    public final void rule__ExponentialExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6738:1: ( ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) )
            // InternalSolverLanguageParser.g:6739:1: ( ( rule__ExponentialExpression__OpAssignment_1_1 ) )
            {
            // InternalSolverLanguageParser.g:6739:1: ( ( rule__ExponentialExpression__OpAssignment_1_1 ) )
            // InternalSolverLanguageParser.g:6740:2: ( rule__ExponentialExpression__OpAssignment_1_1 )
            {
             before(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); 
            // InternalSolverLanguageParser.g:6741:2: ( rule__ExponentialExpression__OpAssignment_1_1 )
            // InternalSolverLanguageParser.g:6741:3: rule__ExponentialExpression__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__OpAssignment_1_1();

            state._fsp--;


            }

             after(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group_1__1__Impl"


    // $ANTLR start "rule__ExponentialExpression__Group_1__2"
    // InternalSolverLanguageParser.g:6749:1: rule__ExponentialExpression__Group_1__2 : rule__ExponentialExpression__Group_1__2__Impl ;
    public final void rule__ExponentialExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6753:1: ( rule__ExponentialExpression__Group_1__2__Impl )
            // InternalSolverLanguageParser.g:6754:2: rule__ExponentialExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__Group_1__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group_1__2"


    // $ANTLR start "rule__ExponentialExpression__Group_1__2__Impl"
    // InternalSolverLanguageParser.g:6760:1: rule__ExponentialExpression__Group_1__2__Impl : ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) ;
    public final void rule__ExponentialExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6764:1: ( ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) )
            // InternalSolverLanguageParser.g:6765:1: ( ( rule__ExponentialExpression__RightAssignment_1_2 ) )
            {
            // InternalSolverLanguageParser.g:6765:1: ( ( rule__ExponentialExpression__RightAssignment_1_2 ) )
            // InternalSolverLanguageParser.g:6766:2: ( rule__ExponentialExpression__RightAssignment_1_2 )
            {
             before(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); 
            // InternalSolverLanguageParser.g:6767:2: ( rule__ExponentialExpression__RightAssignment_1_2 )
            // InternalSolverLanguageParser.g:6767:3: rule__ExponentialExpression__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__ExponentialExpression__RightAssignment_1_2();

            state._fsp--;


            }

             after(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__Group_1__2__Impl"


    // $ANTLR start "rule__CastExpression__Group__0"
    // InternalSolverLanguageParser.g:6776:1: rule__CastExpression__Group__0 : rule__CastExpression__Group__0__Impl rule__CastExpression__Group__1 ;
    public final void rule__CastExpression__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6780:1: ( rule__CastExpression__Group__0__Impl rule__CastExpression__Group__1 )
            // InternalSolverLanguageParser.g:6781:2: rule__CastExpression__Group__0__Impl rule__CastExpression__Group__1
            {
            pushFollow(FOLLOW_9);
            rule__CastExpression__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__CastExpression__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group__0"


    // $ANTLR start "rule__CastExpression__Group__0__Impl"
    // InternalSolverLanguageParser.g:6788:1: rule__CastExpression__Group__0__Impl : ( ruleUnaryExpression ) ;
    public final void rule__CastExpression__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6792:1: ( ( ruleUnaryExpression ) )
            // InternalSolverLanguageParser.g:6793:1: ( ruleUnaryExpression )
            {
            // InternalSolverLanguageParser.g:6793:1: ( ruleUnaryExpression )
            // InternalSolverLanguageParser.g:6794:2: ruleUnaryExpression
            {
             before(grammarAccess.getCastExpressionAccess().getUnaryExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleUnaryExpression();

            state._fsp--;

             after(grammarAccess.getCastExpressionAccess().getUnaryExpressionParserRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group__0__Impl"


    // $ANTLR start "rule__CastExpression__Group__1"
    // InternalSolverLanguageParser.g:6803:1: rule__CastExpression__Group__1 : rule__CastExpression__Group__1__Impl ;
    public final void rule__CastExpression__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6807:1: ( rule__CastExpression__Group__1__Impl )
            // InternalSolverLanguageParser.g:6808:2: rule__CastExpression__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CastExpression__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group__1"


    // $ANTLR start "rule__CastExpression__Group__1__Impl"
    // InternalSolverLanguageParser.g:6814:1: rule__CastExpression__Group__1__Impl : ( ( rule__CastExpression__Group_1__0 )? ) ;
    public final void rule__CastExpression__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6818:1: ( ( ( rule__CastExpression__Group_1__0 )? ) )
            // InternalSolverLanguageParser.g:6819:1: ( ( rule__CastExpression__Group_1__0 )? )
            {
            // InternalSolverLanguageParser.g:6819:1: ( ( rule__CastExpression__Group_1__0 )? )
            // InternalSolverLanguageParser.g:6820:2: ( rule__CastExpression__Group_1__0 )?
            {
             before(grammarAccess.getCastExpressionAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:6821:2: ( rule__CastExpression__Group_1__0 )?
            int alt50=2;
            int LA50_0 = input.LA(1);

            if ( (LA50_0==As) ) {
                alt50=1;
            }
            switch (alt50) {
                case 1 :
                    // InternalSolverLanguageParser.g:6821:3: rule__CastExpression__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CastExpression__Group_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getCastExpressionAccess().getGroup_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group__1__Impl"


    // $ANTLR start "rule__CastExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6830:1: rule__CastExpression__Group_1__0 : rule__CastExpression__Group_1__0__Impl rule__CastExpression__Group_1__1 ;
    public final void rule__CastExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6834:1: ( rule__CastExpression__Group_1__0__Impl rule__CastExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6835:2: rule__CastExpression__Group_1__0__Impl rule__CastExpression__Group_1__1
            {
            pushFollow(FOLLOW_9);
            rule__CastExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__CastExpression__Group_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group_1__0"


    // $ANTLR start "rule__CastExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6842:1: rule__CastExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__CastExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6846:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6847:1: ( () )
            {
            // InternalSolverLanguageParser.g:6847:1: ( () )
            // InternalSolverLanguageParser.g:6848:2: ()
            {
             before(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0()); 
            // InternalSolverLanguageParser.g:6849:2: ()
            // InternalSolverLanguageParser.g:6849:3: 
            {
            }

             after(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group_1__0__Impl"


    // $ANTLR start "rule__CastExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6857:1: rule__CastExpression__Group_1__1 : rule__CastExpression__Group_1__1__Impl rule__CastExpression__Group_1__2 ;
    public final void rule__CastExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6861:1: ( rule__CastExpression__Group_1__1__Impl rule__CastExpression__Group_1__2 )
            // InternalSolverLanguageParser.g:6862:2: rule__CastExpression__Group_1__1__Impl rule__CastExpression__Group_1__2
            {
            pushFollow(FOLLOW_6);
            rule__CastExpression__Group_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__CastExpression__Group_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group_1__1"


    // $ANTLR start "rule__CastExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6869:1: rule__CastExpression__Group_1__1__Impl : ( As ) ;
    public final void rule__CastExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6873:1: ( ( As ) )
            // InternalSolverLanguageParser.g:6874:1: ( As )
            {
            // InternalSolverLanguageParser.g:6874:1: ( As )
            // InternalSolverLanguageParser.g:6875:2: As
            {
             before(grammarAccess.getCastExpressionAccess().getAsKeyword_1_1()); 
            match(input,As,FOLLOW_2); 
             after(grammarAccess.getCastExpressionAccess().getAsKeyword_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group_1__1__Impl"


    // $ANTLR start "rule__CastExpression__Group_1__2"
    // InternalSolverLanguageParser.g:6884:1: rule__CastExpression__Group_1__2 : rule__CastExpression__Group_1__2__Impl ;
    public final void rule__CastExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6888:1: ( rule__CastExpression__Group_1__2__Impl )
            // InternalSolverLanguageParser.g:6889:2: rule__CastExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CastExpression__Group_1__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group_1__2"


    // $ANTLR start "rule__CastExpression__Group_1__2__Impl"
    // InternalSolverLanguageParser.g:6895:1: rule__CastExpression__Group_1__2__Impl : ( ( rule__CastExpression__TargetTypeAssignment_1_2 ) ) ;
    public final void rule__CastExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6899:1: ( ( ( rule__CastExpression__TargetTypeAssignment_1_2 ) ) )
            // InternalSolverLanguageParser.g:6900:1: ( ( rule__CastExpression__TargetTypeAssignment_1_2 ) )
            {
            // InternalSolverLanguageParser.g:6900:1: ( ( rule__CastExpression__TargetTypeAssignment_1_2 ) )
            // InternalSolverLanguageParser.g:6901:2: ( rule__CastExpression__TargetTypeAssignment_1_2 )
            {
             before(grammarAccess.getCastExpressionAccess().getTargetTypeAssignment_1_2()); 
            // InternalSolverLanguageParser.g:6902:2: ( rule__CastExpression__TargetTypeAssignment_1_2 )
            // InternalSolverLanguageParser.g:6902:3: rule__CastExpression__TargetTypeAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__CastExpression__TargetTypeAssignment_1_2();

            state._fsp--;


            }

             after(grammarAccess.getCastExpressionAccess().getTargetTypeAssignment_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__Group_1__2__Impl"


    // $ANTLR start "rule__UnaryExpression__Group_1__0"
    // InternalSolverLanguageParser.g:6911:1: rule__UnaryExpression__Group_1__0 : rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 ;
    public final void rule__UnaryExpression__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6915:1: ( rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 )
            // InternalSolverLanguageParser.g:6916:2: rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1
            {
            pushFollow(FOLLOW_12);
            rule__UnaryExpression__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnaryExpression__Group_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__Group_1__0"


    // $ANTLR start "rule__UnaryExpression__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:6923:1: rule__UnaryExpression__Group_1__0__Impl : ( () ) ;
    public final void rule__UnaryExpression__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6927:1: ( ( () ) )
            // InternalSolverLanguageParser.g:6928:1: ( () )
            {
            // InternalSolverLanguageParser.g:6928:1: ( () )
            // InternalSolverLanguageParser.g:6929:2: ()
            {
             before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); 
            // InternalSolverLanguageParser.g:6930:2: ()
            // InternalSolverLanguageParser.g:6930:3: 
            {
            }

             after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__Group_1__0__Impl"


    // $ANTLR start "rule__UnaryExpression__Group_1__1"
    // InternalSolverLanguageParser.g:6938:1: rule__UnaryExpression__Group_1__1 : rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 ;
    public final void rule__UnaryExpression__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6942:1: ( rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 )
            // InternalSolverLanguageParser.g:6943:2: rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2
            {
            pushFollow(FOLLOW_42);
            rule__UnaryExpression__Group_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnaryExpression__Group_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__Group_1__1"


    // $ANTLR start "rule__UnaryExpression__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:6950:1: rule__UnaryExpression__Group_1__1__Impl : ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) ;
    public final void rule__UnaryExpression__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6954:1: ( ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) )
            // InternalSolverLanguageParser.g:6955:1: ( ( rule__UnaryExpression__OpAssignment_1_1 ) )
            {
            // InternalSolverLanguageParser.g:6955:1: ( ( rule__UnaryExpression__OpAssignment_1_1 ) )
            // InternalSolverLanguageParser.g:6956:2: ( rule__UnaryExpression__OpAssignment_1_1 )
            {
             before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); 
            // InternalSolverLanguageParser.g:6957:2: ( rule__UnaryExpression__OpAssignment_1_1 )
            // InternalSolverLanguageParser.g:6957:3: rule__UnaryExpression__OpAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__UnaryExpression__OpAssignment_1_1();

            state._fsp--;


            }

             after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__Group_1__1__Impl"


    // $ANTLR start "rule__UnaryExpression__Group_1__2"
    // InternalSolverLanguageParser.g:6965:1: rule__UnaryExpression__Group_1__2 : rule__UnaryExpression__Group_1__2__Impl ;
    public final void rule__UnaryExpression__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6969:1: ( rule__UnaryExpression__Group_1__2__Impl )
            // InternalSolverLanguageParser.g:6970:2: rule__UnaryExpression__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UnaryExpression__Group_1__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__Group_1__2"


    // $ANTLR start "rule__UnaryExpression__Group_1__2__Impl"
    // InternalSolverLanguageParser.g:6976:1: rule__UnaryExpression__Group_1__2__Impl : ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) ;
    public final void rule__UnaryExpression__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6980:1: ( ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) )
            // InternalSolverLanguageParser.g:6981:1: ( ( rule__UnaryExpression__BodyAssignment_1_2 ) )
            {
            // InternalSolverLanguageParser.g:6981:1: ( ( rule__UnaryExpression__BodyAssignment_1_2 ) )
            // InternalSolverLanguageParser.g:6982:2: ( rule__UnaryExpression__BodyAssignment_1_2 )
            {
             before(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); 
            // InternalSolverLanguageParser.g:6983:2: ( rule__UnaryExpression__BodyAssignment_1_2 )
            // InternalSolverLanguageParser.g:6983:3: rule__UnaryExpression__BodyAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__UnaryExpression__BodyAssignment_1_2();

            state._fsp--;


            }

             after(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__Group_1__2__Impl"


    // $ANTLR start "rule__Aggregation__Group__0"
    // InternalSolverLanguageParser.g:6992:1: rule__Aggregation__Group__0 : rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 ;
    public final void rule__Aggregation__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:6996:1: ( rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 )
            // InternalSolverLanguageParser.g:6997:2: rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1
            {
            pushFollow(FOLLOW_21);
            rule__Aggregation__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__0"


    // $ANTLR start "rule__Aggregation__Group__0__Impl"
    // InternalSolverLanguageParser.g:7004:1: rule__Aggregation__Group__0__Impl : ( ( rule__Aggregation__OpAssignment_0 ) ) ;
    public final void rule__Aggregation__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7008:1: ( ( ( rule__Aggregation__OpAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:7009:1: ( ( rule__Aggregation__OpAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:7009:1: ( ( rule__Aggregation__OpAssignment_0 ) )
            // InternalSolverLanguageParser.g:7010:2: ( rule__Aggregation__OpAssignment_0 )
            {
             before(grammarAccess.getAggregationAccess().getOpAssignment_0()); 
            // InternalSolverLanguageParser.g:7011:2: ( rule__Aggregation__OpAssignment_0 )
            // InternalSolverLanguageParser.g:7011:3: rule__Aggregation__OpAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__Aggregation__OpAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getAggregationAccess().getOpAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__0__Impl"


    // $ANTLR start "rule__Aggregation__Group__1"
    // InternalSolverLanguageParser.g:7019:1: rule__Aggregation__Group__1 : rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 ;
    public final void rule__Aggregation__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7023:1: ( rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 )
            // InternalSolverLanguageParser.g:7024:2: rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2
            {
            pushFollow(FOLLOW_12);
            rule__Aggregation__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__1"


    // $ANTLR start "rule__Aggregation__Group__1__Impl"
    // InternalSolverLanguageParser.g:7031:1: rule__Aggregation__Group__1__Impl : ( LeftCurlyBracket ) ;
    public final void rule__Aggregation__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7035:1: ( ( LeftCurlyBracket ) )
            // InternalSolverLanguageParser.g:7036:1: ( LeftCurlyBracket )
            {
            // InternalSolverLanguageParser.g:7036:1: ( LeftCurlyBracket )
            // InternalSolverLanguageParser.g:7037:2: LeftCurlyBracket
            {
             before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); 
            match(input,LeftCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__1__Impl"


    // $ANTLR start "rule__Aggregation__Group__2"
    // InternalSolverLanguageParser.g:7046:1: rule__Aggregation__Group__2 : rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 ;
    public final void rule__Aggregation__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7050:1: ( rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 )
            // InternalSolverLanguageParser.g:7051:2: rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3
            {
            pushFollow(FOLLOW_43);
            rule__Aggregation__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__2"


    // $ANTLR start "rule__Aggregation__Group__2__Impl"
    // InternalSolverLanguageParser.g:7058:1: rule__Aggregation__Group__2__Impl : ( ( rule__Aggregation__ValueAssignment_2 ) ) ;
    public final void rule__Aggregation__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7062:1: ( ( ( rule__Aggregation__ValueAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:7063:1: ( ( rule__Aggregation__ValueAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:7063:1: ( ( rule__Aggregation__ValueAssignment_2 ) )
            // InternalSolverLanguageParser.g:7064:2: ( rule__Aggregation__ValueAssignment_2 )
            {
             before(grammarAccess.getAggregationAccess().getValueAssignment_2()); 
            // InternalSolverLanguageParser.g:7065:2: ( rule__Aggregation__ValueAssignment_2 )
            // InternalSolverLanguageParser.g:7065:3: rule__Aggregation__ValueAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__Aggregation__ValueAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getAggregationAccess().getValueAssignment_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__2__Impl"


    // $ANTLR start "rule__Aggregation__Group__3"
    // InternalSolverLanguageParser.g:7073:1: rule__Aggregation__Group__3 : rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 ;
    public final void rule__Aggregation__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7077:1: ( rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 )
            // InternalSolverLanguageParser.g:7078:2: rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4
            {
            pushFollow(FOLLOW_12);
            rule__Aggregation__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__4();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__3"


    // $ANTLR start "rule__Aggregation__Group__3__Impl"
    // InternalSolverLanguageParser.g:7085:1: rule__Aggregation__Group__3__Impl : ( VerticalLine ) ;
    public final void rule__Aggregation__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7089:1: ( ( VerticalLine ) )
            // InternalSolverLanguageParser.g:7090:1: ( VerticalLine )
            {
            // InternalSolverLanguageParser.g:7090:1: ( VerticalLine )
            // InternalSolverLanguageParser.g:7091:2: VerticalLine
            {
             before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); 
            match(input,VerticalLine,FOLLOW_2); 
             after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__3__Impl"


    // $ANTLR start "rule__Aggregation__Group__4"
    // InternalSolverLanguageParser.g:7100:1: rule__Aggregation__Group__4 : rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 ;
    public final void rule__Aggregation__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7104:1: ( rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 )
            // InternalSolverLanguageParser.g:7105:2: rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5
            {
            pushFollow(FOLLOW_23);
            rule__Aggregation__Group__4__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__5();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__4"


    // $ANTLR start "rule__Aggregation__Group__4__Impl"
    // InternalSolverLanguageParser.g:7112:1: rule__Aggregation__Group__4__Impl : ( ( rule__Aggregation__ConditionAssignment_4 ) ) ;
    public final void rule__Aggregation__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7116:1: ( ( ( rule__Aggregation__ConditionAssignment_4 ) ) )
            // InternalSolverLanguageParser.g:7117:1: ( ( rule__Aggregation__ConditionAssignment_4 ) )
            {
            // InternalSolverLanguageParser.g:7117:1: ( ( rule__Aggregation__ConditionAssignment_4 ) )
            // InternalSolverLanguageParser.g:7118:2: ( rule__Aggregation__ConditionAssignment_4 )
            {
             before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); 
            // InternalSolverLanguageParser.g:7119:2: ( rule__Aggregation__ConditionAssignment_4 )
            // InternalSolverLanguageParser.g:7119:3: rule__Aggregation__ConditionAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__Aggregation__ConditionAssignment_4();

            state._fsp--;


            }

             after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__4__Impl"


    // $ANTLR start "rule__Aggregation__Group__5"
    // InternalSolverLanguageParser.g:7127:1: rule__Aggregation__Group__5 : rule__Aggregation__Group__5__Impl ;
    public final void rule__Aggregation__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7131:1: ( rule__Aggregation__Group__5__Impl )
            // InternalSolverLanguageParser.g:7132:2: rule__Aggregation__Group__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Aggregation__Group__5__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__5"


    // $ANTLR start "rule__Aggregation__Group__5__Impl"
    // InternalSolverLanguageParser.g:7138:1: rule__Aggregation__Group__5__Impl : ( RightCurlyBracket ) ;
    public final void rule__Aggregation__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7142:1: ( ( RightCurlyBracket ) )
            // InternalSolverLanguageParser.g:7143:1: ( RightCurlyBracket )
            {
            // InternalSolverLanguageParser.g:7143:1: ( RightCurlyBracket )
            // InternalSolverLanguageParser.g:7144:2: RightCurlyBracket
            {
             before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); 
            match(input,RightCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__Group__5__Impl"


    // $ANTLR start "rule__Count__Group__0"
    // InternalSolverLanguageParser.g:7154:1: rule__Count__Group__0 : rule__Count__Group__0__Impl rule__Count__Group__1 ;
    public final void rule__Count__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7158:1: ( rule__Count__Group__0__Impl rule__Count__Group__1 )
            // InternalSolverLanguageParser.g:7159:2: rule__Count__Group__0__Impl rule__Count__Group__1
            {
            pushFollow(FOLLOW_21);
            rule__Count__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Count__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__0"


    // $ANTLR start "rule__Count__Group__0__Impl"
    // InternalSolverLanguageParser.g:7166:1: rule__Count__Group__0__Impl : ( Count ) ;
    public final void rule__Count__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7170:1: ( ( Count ) )
            // InternalSolverLanguageParser.g:7171:1: ( Count )
            {
            // InternalSolverLanguageParser.g:7171:1: ( Count )
            // InternalSolverLanguageParser.g:7172:2: Count
            {
             before(grammarAccess.getCountAccess().getCountKeyword_0()); 
            match(input,Count,FOLLOW_2); 
             after(grammarAccess.getCountAccess().getCountKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__0__Impl"


    // $ANTLR start "rule__Count__Group__1"
    // InternalSolverLanguageParser.g:7181:1: rule__Count__Group__1 : rule__Count__Group__1__Impl rule__Count__Group__2 ;
    public final void rule__Count__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7185:1: ( rule__Count__Group__1__Impl rule__Count__Group__2 )
            // InternalSolverLanguageParser.g:7186:2: rule__Count__Group__1__Impl rule__Count__Group__2
            {
            pushFollow(FOLLOW_12);
            rule__Count__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Count__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__1"


    // $ANTLR start "rule__Count__Group__1__Impl"
    // InternalSolverLanguageParser.g:7193:1: rule__Count__Group__1__Impl : ( LeftCurlyBracket ) ;
    public final void rule__Count__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7197:1: ( ( LeftCurlyBracket ) )
            // InternalSolverLanguageParser.g:7198:1: ( LeftCurlyBracket )
            {
            // InternalSolverLanguageParser.g:7198:1: ( LeftCurlyBracket )
            // InternalSolverLanguageParser.g:7199:2: LeftCurlyBracket
            {
             before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); 
            match(input,LeftCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__1__Impl"


    // $ANTLR start "rule__Count__Group__2"
    // InternalSolverLanguageParser.g:7208:1: rule__Count__Group__2 : rule__Count__Group__2__Impl rule__Count__Group__3 ;
    public final void rule__Count__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7212:1: ( rule__Count__Group__2__Impl rule__Count__Group__3 )
            // InternalSolverLanguageParser.g:7213:2: rule__Count__Group__2__Impl rule__Count__Group__3
            {
            pushFollow(FOLLOW_23);
            rule__Count__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Count__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__2"


    // $ANTLR start "rule__Count__Group__2__Impl"
    // InternalSolverLanguageParser.g:7220:1: rule__Count__Group__2__Impl : ( ( rule__Count__ConditionAssignment_2 ) ) ;
    public final void rule__Count__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7224:1: ( ( ( rule__Count__ConditionAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:7225:1: ( ( rule__Count__ConditionAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:7225:1: ( ( rule__Count__ConditionAssignment_2 ) )
            // InternalSolverLanguageParser.g:7226:2: ( rule__Count__ConditionAssignment_2 )
            {
             before(grammarAccess.getCountAccess().getConditionAssignment_2()); 
            // InternalSolverLanguageParser.g:7227:2: ( rule__Count__ConditionAssignment_2 )
            // InternalSolverLanguageParser.g:7227:3: rule__Count__ConditionAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__Count__ConditionAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getCountAccess().getConditionAssignment_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__2__Impl"


    // $ANTLR start "rule__Count__Group__3"
    // InternalSolverLanguageParser.g:7235:1: rule__Count__Group__3 : rule__Count__Group__3__Impl ;
    public final void rule__Count__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7239:1: ( rule__Count__Group__3__Impl )
            // InternalSolverLanguageParser.g:7240:2: rule__Count__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Count__Group__3__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__3"


    // $ANTLR start "rule__Count__Group__3__Impl"
    // InternalSolverLanguageParser.g:7246:1: rule__Count__Group__3__Impl : ( RightCurlyBracket ) ;
    public final void rule__Count__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7250:1: ( ( RightCurlyBracket ) )
            // InternalSolverLanguageParser.g:7251:1: ( RightCurlyBracket )
            {
            // InternalSolverLanguageParser.g:7251:1: ( RightCurlyBracket )
            // InternalSolverLanguageParser.g:7252:2: RightCurlyBracket
            {
             before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); 
            match(input,RightCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__Group__3__Impl"


    // $ANTLR start "rule__AtomicExpression__Group_4__0"
    // InternalSolverLanguageParser.g:7262:1: rule__AtomicExpression__Group_4__0 : rule__AtomicExpression__Group_4__0__Impl rule__AtomicExpression__Group_4__1 ;
    public final void rule__AtomicExpression__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7266:1: ( rule__AtomicExpression__Group_4__0__Impl rule__AtomicExpression__Group_4__1 )
            // InternalSolverLanguageParser.g:7267:2: rule__AtomicExpression__Group_4__0__Impl rule__AtomicExpression__Group_4__1
            {
            pushFollow(FOLLOW_12);
            rule__AtomicExpression__Group_4__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AtomicExpression__Group_4__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AtomicExpression__Group_4__0"


    // $ANTLR start "rule__AtomicExpression__Group_4__0__Impl"
    // InternalSolverLanguageParser.g:7274:1: rule__AtomicExpression__Group_4__0__Impl : ( LeftParenthesis ) ;
    public final void rule__AtomicExpression__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7278:1: ( ( LeftParenthesis ) )
            // InternalSolverLanguageParser.g:7279:1: ( LeftParenthesis )
            {
            // InternalSolverLanguageParser.g:7279:1: ( LeftParenthesis )
            // InternalSolverLanguageParser.g:7280:2: LeftParenthesis
            {
             before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); 
            match(input,LeftParenthesis,FOLLOW_2); 
             after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AtomicExpression__Group_4__0__Impl"


    // $ANTLR start "rule__AtomicExpression__Group_4__1"
    // InternalSolverLanguageParser.g:7289:1: rule__AtomicExpression__Group_4__1 : rule__AtomicExpression__Group_4__1__Impl rule__AtomicExpression__Group_4__2 ;
    public final void rule__AtomicExpression__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7293:1: ( rule__AtomicExpression__Group_4__1__Impl rule__AtomicExpression__Group_4__2 )
            // InternalSolverLanguageParser.g:7294:2: rule__AtomicExpression__Group_4__1__Impl rule__AtomicExpression__Group_4__2
            {
            pushFollow(FOLLOW_44);
            rule__AtomicExpression__Group_4__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__AtomicExpression__Group_4__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AtomicExpression__Group_4__1"


    // $ANTLR start "rule__AtomicExpression__Group_4__1__Impl"
    // InternalSolverLanguageParser.g:7301:1: rule__AtomicExpression__Group_4__1__Impl : ( ruleExpression ) ;
    public final void rule__AtomicExpression__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7305:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:7306:1: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:7306:1: ( ruleExpression )
            // InternalSolverLanguageParser.g:7307:2: ruleExpression
            {
             before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AtomicExpression__Group_4__1__Impl"


    // $ANTLR start "rule__AtomicExpression__Group_4__2"
    // InternalSolverLanguageParser.g:7316:1: rule__AtomicExpression__Group_4__2 : rule__AtomicExpression__Group_4__2__Impl ;
    public final void rule__AtomicExpression__Group_4__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7320:1: ( rule__AtomicExpression__Group_4__2__Impl )
            // InternalSolverLanguageParser.g:7321:2: rule__AtomicExpression__Group_4__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AtomicExpression__Group_4__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AtomicExpression__Group_4__2"


    // $ANTLR start "rule__AtomicExpression__Group_4__2__Impl"
    // InternalSolverLanguageParser.g:7327:1: rule__AtomicExpression__Group_4__2__Impl : ( RightParenthesis ) ;
    public final void rule__AtomicExpression__Group_4__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7331:1: ( ( RightParenthesis ) )
            // InternalSolverLanguageParser.g:7332:1: ( RightParenthesis )
            {
            // InternalSolverLanguageParser.g:7332:1: ( RightParenthesis )
            // InternalSolverLanguageParser.g:7333:2: RightParenthesis
            {
             before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); 
            match(input,RightParenthesis,FOLLOW_2); 
             after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AtomicExpression__Group_4__2__Impl"


    // $ANTLR start "rule__Call__Group__0"
    // InternalSolverLanguageParser.g:7343:1: rule__Call__Group__0 : rule__Call__Group__0__Impl rule__Call__Group__1 ;
    public final void rule__Call__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7347:1: ( rule__Call__Group__0__Impl rule__Call__Group__1 )
            // InternalSolverLanguageParser.g:7348:2: rule__Call__Group__0__Impl rule__Call__Group__1
            {
            pushFollow(FOLLOW_16);
            rule__Call__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Call__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Call__Group__0"


    // $ANTLR start "rule__Call__Group__0__Impl"
    // InternalSolverLanguageParser.g:7355:1: rule__Call__Group__0__Impl : ( ( rule__Call__FunctorAssignment_0 ) ) ;
    public final void rule__Call__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7359:1: ( ( ( rule__Call__FunctorAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:7360:1: ( ( rule__Call__FunctorAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:7360:1: ( ( rule__Call__FunctorAssignment_0 ) )
            // InternalSolverLanguageParser.g:7361:2: ( rule__Call__FunctorAssignment_0 )
            {
             before(grammarAccess.getCallAccess().getFunctorAssignment_0()); 
            // InternalSolverLanguageParser.g:7362:2: ( rule__Call__FunctorAssignment_0 )
            // InternalSolverLanguageParser.g:7362:3: rule__Call__FunctorAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__Call__FunctorAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getCallAccess().getFunctorAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Call__Group__0__Impl"


    // $ANTLR start "rule__Call__Group__1"
    // InternalSolverLanguageParser.g:7370:1: rule__Call__Group__1 : rule__Call__Group__1__Impl ;
    public final void rule__Call__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7374:1: ( rule__Call__Group__1__Impl )
            // InternalSolverLanguageParser.g:7375:2: rule__Call__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Call__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Call__Group__1"


    // $ANTLR start "rule__Call__Group__1__Impl"
    // InternalSolverLanguageParser.g:7381:1: rule__Call__Group__1__Impl : ( ( rule__Call__ArgumentListAssignment_1 ) ) ;
    public final void rule__Call__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7385:1: ( ( ( rule__Call__ArgumentListAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:7386:1: ( ( rule__Call__ArgumentListAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:7386:1: ( ( rule__Call__ArgumentListAssignment_1 ) )
            // InternalSolverLanguageParser.g:7387:2: ( rule__Call__ArgumentListAssignment_1 )
            {
             before(grammarAccess.getCallAccess().getArgumentListAssignment_1()); 
            // InternalSolverLanguageParser.g:7388:2: ( rule__Call__ArgumentListAssignment_1 )
            // InternalSolverLanguageParser.g:7388:3: rule__Call__ArgumentListAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__Call__ArgumentListAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getCallAccess().getArgumentListAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Call__Group__1__Impl"


    // $ANTLR start "rule__ArgumentList__Group__0"
    // InternalSolverLanguageParser.g:7397:1: rule__ArgumentList__Group__0 : rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 ;
    public final void rule__ArgumentList__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7401:1: ( rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 )
            // InternalSolverLanguageParser.g:7402:2: rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1
            {
            pushFollow(FOLLOW_16);
            rule__ArgumentList__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__0"


    // $ANTLR start "rule__ArgumentList__Group__0__Impl"
    // InternalSolverLanguageParser.g:7409:1: rule__ArgumentList__Group__0__Impl : ( () ) ;
    public final void rule__ArgumentList__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7413:1: ( ( () ) )
            // InternalSolverLanguageParser.g:7414:1: ( () )
            {
            // InternalSolverLanguageParser.g:7414:1: ( () )
            // InternalSolverLanguageParser.g:7415:2: ()
            {
             before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); 
            // InternalSolverLanguageParser.g:7416:2: ()
            // InternalSolverLanguageParser.g:7416:3: 
            {
            }

             after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__0__Impl"


    // $ANTLR start "rule__ArgumentList__Group__1"
    // InternalSolverLanguageParser.g:7424:1: rule__ArgumentList__Group__1 : rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 ;
    public final void rule__ArgumentList__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7428:1: ( rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 )
            // InternalSolverLanguageParser.g:7429:2: rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2
            {
            pushFollow(FOLLOW_45);
            rule__ArgumentList__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__1"


    // $ANTLR start "rule__ArgumentList__Group__1__Impl"
    // InternalSolverLanguageParser.g:7436:1: rule__ArgumentList__Group__1__Impl : ( LeftParenthesis ) ;
    public final void rule__ArgumentList__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7440:1: ( ( LeftParenthesis ) )
            // InternalSolverLanguageParser.g:7441:1: ( LeftParenthesis )
            {
            // InternalSolverLanguageParser.g:7441:1: ( LeftParenthesis )
            // InternalSolverLanguageParser.g:7442:2: LeftParenthesis
            {
             before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); 
            match(input,LeftParenthesis,FOLLOW_2); 
             after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__1__Impl"


    // $ANTLR start "rule__ArgumentList__Group__2"
    // InternalSolverLanguageParser.g:7451:1: rule__ArgumentList__Group__2 : rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 ;
    public final void rule__ArgumentList__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7455:1: ( rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 )
            // InternalSolverLanguageParser.g:7456:2: rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3
            {
            pushFollow(FOLLOW_45);
            rule__ArgumentList__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__2"


    // $ANTLR start "rule__ArgumentList__Group__2__Impl"
    // InternalSolverLanguageParser.g:7463:1: rule__ArgumentList__Group__2__Impl : ( ( rule__ArgumentList__Group_2__0 )? ) ;
    public final void rule__ArgumentList__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7467:1: ( ( ( rule__ArgumentList__Group_2__0 )? ) )
            // InternalSolverLanguageParser.g:7468:1: ( ( rule__ArgumentList__Group_2__0 )? )
            {
            // InternalSolverLanguageParser.g:7468:1: ( ( rule__ArgumentList__Group_2__0 )? )
            // InternalSolverLanguageParser.g:7469:2: ( rule__ArgumentList__Group_2__0 )?
            {
             before(grammarAccess.getArgumentListAccess().getGroup_2()); 
            // InternalSolverLanguageParser.g:7470:2: ( rule__ArgumentList__Group_2__0 )?
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==Unknown||LA51_0==Object||(LA51_0>=Count && LA51_0<=False)||LA51_0==True||LA51_0==Inf||(LA51_0>=ExclamationMark && LA51_0<=LeftParenthesis)||(LA51_0>=Asterisk && LA51_0<=PlusSign)||LA51_0==HyphenMinus||(LA51_0>=QuestionMark && LA51_0<=LeftSquareBracket)||(LA51_0>=Tilde && LA51_0<=RULE_QUOTED_ID)||(LA51_0>=RULE_ID && LA51_0<=RULE_INT)) ) {
                alt51=1;
            }
            switch (alt51) {
                case 1 :
                    // InternalSolverLanguageParser.g:7470:3: rule__ArgumentList__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ArgumentList__Group_2__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getArgumentListAccess().getGroup_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__2__Impl"


    // $ANTLR start "rule__ArgumentList__Group__3"
    // InternalSolverLanguageParser.g:7478:1: rule__ArgumentList__Group__3 : rule__ArgumentList__Group__3__Impl ;
    public final void rule__ArgumentList__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7482:1: ( rule__ArgumentList__Group__3__Impl )
            // InternalSolverLanguageParser.g:7483:2: rule__ArgumentList__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group__3__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__3"


    // $ANTLR start "rule__ArgumentList__Group__3__Impl"
    // InternalSolverLanguageParser.g:7489:1: rule__ArgumentList__Group__3__Impl : ( RightParenthesis ) ;
    public final void rule__ArgumentList__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7493:1: ( ( RightParenthesis ) )
            // InternalSolverLanguageParser.g:7494:1: ( RightParenthesis )
            {
            // InternalSolverLanguageParser.g:7494:1: ( RightParenthesis )
            // InternalSolverLanguageParser.g:7495:2: RightParenthesis
            {
             before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); 
            match(input,RightParenthesis,FOLLOW_2); 
             after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group__3__Impl"


    // $ANTLR start "rule__ArgumentList__Group_2__0"
    // InternalSolverLanguageParser.g:7505:1: rule__ArgumentList__Group_2__0 : rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 ;
    public final void rule__ArgumentList__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7509:1: ( rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 )
            // InternalSolverLanguageParser.g:7510:2: rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1
            {
            pushFollow(FOLLOW_35);
            rule__ArgumentList__Group_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group_2__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2__0"


    // $ANTLR start "rule__ArgumentList__Group_2__0__Impl"
    // InternalSolverLanguageParser.g:7517:1: rule__ArgumentList__Group_2__0__Impl : ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) ;
    public final void rule__ArgumentList__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7521:1: ( ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) )
            // InternalSolverLanguageParser.g:7522:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) )
            {
            // InternalSolverLanguageParser.g:7522:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) )
            // InternalSolverLanguageParser.g:7523:2: ( rule__ArgumentList__ArgumentsAssignment_2_0 )
            {
             before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); 
            // InternalSolverLanguageParser.g:7524:2: ( rule__ArgumentList__ArgumentsAssignment_2_0 )
            // InternalSolverLanguageParser.g:7524:3: rule__ArgumentList__ArgumentsAssignment_2_0
            {
            pushFollow(FOLLOW_2);
            rule__ArgumentList__ArgumentsAssignment_2_0();

            state._fsp--;


            }

             after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2__0__Impl"


    // $ANTLR start "rule__ArgumentList__Group_2__1"
    // InternalSolverLanguageParser.g:7532:1: rule__ArgumentList__Group_2__1 : rule__ArgumentList__Group_2__1__Impl ;
    public final void rule__ArgumentList__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7536:1: ( rule__ArgumentList__Group_2__1__Impl )
            // InternalSolverLanguageParser.g:7537:2: rule__ArgumentList__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group_2__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2__1"


    // $ANTLR start "rule__ArgumentList__Group_2__1__Impl"
    // InternalSolverLanguageParser.g:7543:1: rule__ArgumentList__Group_2__1__Impl : ( ( rule__ArgumentList__Group_2_1__0 )* ) ;
    public final void rule__ArgumentList__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7547:1: ( ( ( rule__ArgumentList__Group_2_1__0 )* ) )
            // InternalSolverLanguageParser.g:7548:1: ( ( rule__ArgumentList__Group_2_1__0 )* )
            {
            // InternalSolverLanguageParser.g:7548:1: ( ( rule__ArgumentList__Group_2_1__0 )* )
            // InternalSolverLanguageParser.g:7549:2: ( rule__ArgumentList__Group_2_1__0 )*
            {
             before(grammarAccess.getArgumentListAccess().getGroup_2_1()); 
            // InternalSolverLanguageParser.g:7550:2: ( rule__ArgumentList__Group_2_1__0 )*
            loop52:
            do {
                int alt52=2;
                int LA52_0 = input.LA(1);

                if ( (LA52_0==Comma) ) {
                    alt52=1;
                }


                switch (alt52) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:7550:3: rule__ArgumentList__Group_2_1__0
            	    {
            	    pushFollow(FOLLOW_29);
            	    rule__ArgumentList__Group_2_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop52;
                }
            } while (true);

             after(grammarAccess.getArgumentListAccess().getGroup_2_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2__1__Impl"


    // $ANTLR start "rule__ArgumentList__Group_2_1__0"
    // InternalSolverLanguageParser.g:7559:1: rule__ArgumentList__Group_2_1__0 : rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 ;
    public final void rule__ArgumentList__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7563:1: ( rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 )
            // InternalSolverLanguageParser.g:7564:2: rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1
            {
            pushFollow(FOLLOW_46);
            rule__ArgumentList__Group_2_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group_2_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2_1__0"


    // $ANTLR start "rule__ArgumentList__Group_2_1__0__Impl"
    // InternalSolverLanguageParser.g:7571:1: rule__ArgumentList__Group_2_1__0__Impl : ( Comma ) ;
    public final void rule__ArgumentList__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7575:1: ( ( Comma ) )
            // InternalSolverLanguageParser.g:7576:1: ( Comma )
            {
            // InternalSolverLanguageParser.g:7576:1: ( Comma )
            // InternalSolverLanguageParser.g:7577:2: Comma
            {
             before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); 
            match(input,Comma,FOLLOW_2); 
             after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2_1__0__Impl"


    // $ANTLR start "rule__ArgumentList__Group_2_1__1"
    // InternalSolverLanguageParser.g:7586:1: rule__ArgumentList__Group_2_1__1 : rule__ArgumentList__Group_2_1__1__Impl ;
    public final void rule__ArgumentList__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7590:1: ( rule__ArgumentList__Group_2_1__1__Impl )
            // InternalSolverLanguageParser.g:7591:2: rule__ArgumentList__Group_2_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ArgumentList__Group_2_1__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2_1__1"


    // $ANTLR start "rule__ArgumentList__Group_2_1__1__Impl"
    // InternalSolverLanguageParser.g:7597:1: rule__ArgumentList__Group_2_1__1__Impl : ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) ;
    public final void rule__ArgumentList__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7601:1: ( ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) )
            // InternalSolverLanguageParser.g:7602:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) )
            {
            // InternalSolverLanguageParser.g:7602:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) )
            // InternalSolverLanguageParser.g:7603:2: ( rule__ArgumentList__ArgumentsAssignment_2_1_1 )
            {
             before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); 
            // InternalSolverLanguageParser.g:7604:2: ( rule__ArgumentList__ArgumentsAssignment_2_1_1 )
            // InternalSolverLanguageParser.g:7604:3: rule__ArgumentList__ArgumentsAssignment_2_1_1
            {
            pushFollow(FOLLOW_2);
            rule__ArgumentList__ArgumentsAssignment_2_1_1();

            state._fsp--;


            }

             after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__Group_2_1__1__Impl"


    // $ANTLR start "rule__StarArgument__Group__0"
    // InternalSolverLanguageParser.g:7613:1: rule__StarArgument__Group__0 : rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 ;
    public final void rule__StarArgument__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7617:1: ( rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 )
            // InternalSolverLanguageParser.g:7618:2: rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1
            {
            pushFollow(FOLLOW_47);
            rule__StarArgument__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__StarArgument__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StarArgument__Group__0"


    // $ANTLR start "rule__StarArgument__Group__0__Impl"
    // InternalSolverLanguageParser.g:7625:1: rule__StarArgument__Group__0__Impl : ( () ) ;
    public final void rule__StarArgument__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7629:1: ( ( () ) )
            // InternalSolverLanguageParser.g:7630:1: ( () )
            {
            // InternalSolverLanguageParser.g:7630:1: ( () )
            // InternalSolverLanguageParser.g:7631:2: ()
            {
             before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); 
            // InternalSolverLanguageParser.g:7632:2: ()
            // InternalSolverLanguageParser.g:7632:3: 
            {
            }

             after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StarArgument__Group__0__Impl"


    // $ANTLR start "rule__StarArgument__Group__1"
    // InternalSolverLanguageParser.g:7640:1: rule__StarArgument__Group__1 : rule__StarArgument__Group__1__Impl ;
    public final void rule__StarArgument__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7644:1: ( rule__StarArgument__Group__1__Impl )
            // InternalSolverLanguageParser.g:7645:2: rule__StarArgument__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__StarArgument__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StarArgument__Group__1"


    // $ANTLR start "rule__StarArgument__Group__1__Impl"
    // InternalSolverLanguageParser.g:7651:1: rule__StarArgument__Group__1__Impl : ( Asterisk ) ;
    public final void rule__StarArgument__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7655:1: ( ( Asterisk ) )
            // InternalSolverLanguageParser.g:7656:1: ( Asterisk )
            {
            // InternalSolverLanguageParser.g:7656:1: ( Asterisk )
            // InternalSolverLanguageParser.g:7657:2: Asterisk
            {
             before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); 
            match(input,Asterisk,FOLLOW_2); 
             after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StarArgument__Group__1__Impl"


    // $ANTLR start "rule__TypedVariableArgument__Group__0"
    // InternalSolverLanguageParser.g:7667:1: rule__TypedVariableArgument__Group__0 : rule__TypedVariableArgument__Group__0__Impl rule__TypedVariableArgument__Group__1 ;
    public final void rule__TypedVariableArgument__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7671:1: ( rule__TypedVariableArgument__Group__0__Impl rule__TypedVariableArgument__Group__1 )
            // InternalSolverLanguageParser.g:7672:2: rule__TypedVariableArgument__Group__0__Impl rule__TypedVariableArgument__Group__1
            {
            pushFollow(FOLLOW_48);
            rule__TypedVariableArgument__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__TypedVariableArgument__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedVariableArgument__Group__0"


    // $ANTLR start "rule__TypedVariableArgument__Group__0__Impl"
    // InternalSolverLanguageParser.g:7679:1: rule__TypedVariableArgument__Group__0__Impl : ( ( rule__TypedVariableArgument__TypeReferenceAssignment_0 ) ) ;
    public final void rule__TypedVariableArgument__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7683:1: ( ( ( rule__TypedVariableArgument__TypeReferenceAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:7684:1: ( ( rule__TypedVariableArgument__TypeReferenceAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:7684:1: ( ( rule__TypedVariableArgument__TypeReferenceAssignment_0 ) )
            // InternalSolverLanguageParser.g:7685:2: ( rule__TypedVariableArgument__TypeReferenceAssignment_0 )
            {
             before(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceAssignment_0()); 
            // InternalSolverLanguageParser.g:7686:2: ( rule__TypedVariableArgument__TypeReferenceAssignment_0 )
            // InternalSolverLanguageParser.g:7686:3: rule__TypedVariableArgument__TypeReferenceAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__TypedVariableArgument__TypeReferenceAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedVariableArgument__Group__0__Impl"


    // $ANTLR start "rule__TypedVariableArgument__Group__1"
    // InternalSolverLanguageParser.g:7694:1: rule__TypedVariableArgument__Group__1 : rule__TypedVariableArgument__Group__1__Impl ;
    public final void rule__TypedVariableArgument__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7698:1: ( rule__TypedVariableArgument__Group__1__Impl )
            // InternalSolverLanguageParser.g:7699:2: rule__TypedVariableArgument__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__TypedVariableArgument__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedVariableArgument__Group__1"


    // $ANTLR start "rule__TypedVariableArgument__Group__1__Impl"
    // InternalSolverLanguageParser.g:7705:1: rule__TypedVariableArgument__Group__1__Impl : ( ( rule__TypedVariableArgument__NameAssignment_1 ) ) ;
    public final void rule__TypedVariableArgument__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7709:1: ( ( ( rule__TypedVariableArgument__NameAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:7710:1: ( ( rule__TypedVariableArgument__NameAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:7710:1: ( ( rule__TypedVariableArgument__NameAssignment_1 ) )
            // InternalSolverLanguageParser.g:7711:2: ( rule__TypedVariableArgument__NameAssignment_1 )
            {
             before(grammarAccess.getTypedVariableArgumentAccess().getNameAssignment_1()); 
            // InternalSolverLanguageParser.g:7712:2: ( rule__TypedVariableArgument__NameAssignment_1 )
            // InternalSolverLanguageParser.g:7712:3: rule__TypedVariableArgument__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__TypedVariableArgument__NameAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getTypedVariableArgumentAccess().getNameAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedVariableArgument__Group__1__Impl"


    // $ANTLR start "rule__TypedStarArgument__Group__0"
    // InternalSolverLanguageParser.g:7721:1: rule__TypedStarArgument__Group__0 : rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 ;
    public final void rule__TypedStarArgument__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7725:1: ( rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 )
            // InternalSolverLanguageParser.g:7726:2: rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1
            {
            pushFollow(FOLLOW_47);
            rule__TypedStarArgument__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__TypedStarArgument__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedStarArgument__Group__0"


    // $ANTLR start "rule__TypedStarArgument__Group__0__Impl"
    // InternalSolverLanguageParser.g:7733:1: rule__TypedStarArgument__Group__0__Impl : ( ( rule__TypedStarArgument__TypeReferenceAssignment_0 ) ) ;
    public final void rule__TypedStarArgument__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7737:1: ( ( ( rule__TypedStarArgument__TypeReferenceAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:7738:1: ( ( rule__TypedStarArgument__TypeReferenceAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:7738:1: ( ( rule__TypedStarArgument__TypeReferenceAssignment_0 ) )
            // InternalSolverLanguageParser.g:7739:2: ( rule__TypedStarArgument__TypeReferenceAssignment_0 )
            {
             before(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceAssignment_0()); 
            // InternalSolverLanguageParser.g:7740:2: ( rule__TypedStarArgument__TypeReferenceAssignment_0 )
            // InternalSolverLanguageParser.g:7740:3: rule__TypedStarArgument__TypeReferenceAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__TypedStarArgument__TypeReferenceAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedStarArgument__Group__0__Impl"


    // $ANTLR start "rule__TypedStarArgument__Group__1"
    // InternalSolverLanguageParser.g:7748:1: rule__TypedStarArgument__Group__1 : rule__TypedStarArgument__Group__1__Impl ;
    public final void rule__TypedStarArgument__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7752:1: ( rule__TypedStarArgument__Group__1__Impl )
            // InternalSolverLanguageParser.g:7753:2: rule__TypedStarArgument__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__TypedStarArgument__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedStarArgument__Group__1"


    // $ANTLR start "rule__TypedStarArgument__Group__1__Impl"
    // InternalSolverLanguageParser.g:7759:1: rule__TypedStarArgument__Group__1__Impl : ( Asterisk ) ;
    public final void rule__TypedStarArgument__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7763:1: ( ( Asterisk ) )
            // InternalSolverLanguageParser.g:7764:1: ( Asterisk )
            {
            // InternalSolverLanguageParser.g:7764:1: ( Asterisk )
            // InternalSolverLanguageParser.g:7765:2: Asterisk
            {
             before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); 
            match(input,Asterisk,FOLLOW_2); 
             after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedStarArgument__Group__1__Impl"


    // $ANTLR start "rule__Reference__Group__0"
    // InternalSolverLanguageParser.g:7775:1: rule__Reference__Group__0 : rule__Reference__Group__0__Impl rule__Reference__Group__1 ;
    public final void rule__Reference__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7779:1: ( rule__Reference__Group__0__Impl rule__Reference__Group__1 )
            // InternalSolverLanguageParser.g:7780:2: rule__Reference__Group__0__Impl rule__Reference__Group__1
            {
            pushFollow(FOLLOW_49);
            rule__Reference__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Reference__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group__0"


    // $ANTLR start "rule__Reference__Group__0__Impl"
    // InternalSolverLanguageParser.g:7787:1: rule__Reference__Group__0__Impl : ( ( rule__Reference__ComponentsAssignment_0 ) ) ;
    public final void rule__Reference__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7791:1: ( ( ( rule__Reference__ComponentsAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:7792:1: ( ( rule__Reference__ComponentsAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:7792:1: ( ( rule__Reference__ComponentsAssignment_0 ) )
            // InternalSolverLanguageParser.g:7793:2: ( rule__Reference__ComponentsAssignment_0 )
            {
             before(grammarAccess.getReferenceAccess().getComponentsAssignment_0()); 
            // InternalSolverLanguageParser.g:7794:2: ( rule__Reference__ComponentsAssignment_0 )
            // InternalSolverLanguageParser.g:7794:3: rule__Reference__ComponentsAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__Reference__ComponentsAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getReferenceAccess().getComponentsAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group__0__Impl"


    // $ANTLR start "rule__Reference__Group__1"
    // InternalSolverLanguageParser.g:7802:1: rule__Reference__Group__1 : rule__Reference__Group__1__Impl ;
    public final void rule__Reference__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7806:1: ( rule__Reference__Group__1__Impl )
            // InternalSolverLanguageParser.g:7807:2: rule__Reference__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Reference__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group__1"


    // $ANTLR start "rule__Reference__Group__1__Impl"
    // InternalSolverLanguageParser.g:7813:1: rule__Reference__Group__1__Impl : ( ( rule__Reference__Group_1__0 )* ) ;
    public final void rule__Reference__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7817:1: ( ( ( rule__Reference__Group_1__0 )* ) )
            // InternalSolverLanguageParser.g:7818:1: ( ( rule__Reference__Group_1__0 )* )
            {
            // InternalSolverLanguageParser.g:7818:1: ( ( rule__Reference__Group_1__0 )* )
            // InternalSolverLanguageParser.g:7819:2: ( rule__Reference__Group_1__0 )*
            {
             before(grammarAccess.getReferenceAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:7820:2: ( rule__Reference__Group_1__0 )*
            loop53:
            do {
                int alt53=2;
                int LA53_0 = input.LA(1);

                if ( (LA53_0==FullStop) ) {
                    alt53=1;
                }


                switch (alt53) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:7820:3: rule__Reference__Group_1__0
            	    {
            	    pushFollow(FOLLOW_50);
            	    rule__Reference__Group_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop53;
                }
            } while (true);

             after(grammarAccess.getReferenceAccess().getGroup_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group__1__Impl"


    // $ANTLR start "rule__Reference__Group_1__0"
    // InternalSolverLanguageParser.g:7829:1: rule__Reference__Group_1__0 : rule__Reference__Group_1__0__Impl rule__Reference__Group_1__1 ;
    public final void rule__Reference__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7833:1: ( rule__Reference__Group_1__0__Impl rule__Reference__Group_1__1 )
            // InternalSolverLanguageParser.g:7834:2: rule__Reference__Group_1__0__Impl rule__Reference__Group_1__1
            {
            pushFollow(FOLLOW_6);
            rule__Reference__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Reference__Group_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group_1__0"


    // $ANTLR start "rule__Reference__Group_1__0__Impl"
    // InternalSolverLanguageParser.g:7841:1: rule__Reference__Group_1__0__Impl : ( FullStop ) ;
    public final void rule__Reference__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7845:1: ( ( FullStop ) )
            // InternalSolverLanguageParser.g:7846:1: ( FullStop )
            {
            // InternalSolverLanguageParser.g:7846:1: ( FullStop )
            // InternalSolverLanguageParser.g:7847:2: FullStop
            {
             before(grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); 
            match(input,FullStop,FOLLOW_2); 
             after(grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group_1__0__Impl"


    // $ANTLR start "rule__Reference__Group_1__1"
    // InternalSolverLanguageParser.g:7856:1: rule__Reference__Group_1__1 : rule__Reference__Group_1__1__Impl ;
    public final void rule__Reference__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7860:1: ( rule__Reference__Group_1__1__Impl )
            // InternalSolverLanguageParser.g:7861:2: rule__Reference__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Reference__Group_1__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group_1__1"


    // $ANTLR start "rule__Reference__Group_1__1__Impl"
    // InternalSolverLanguageParser.g:7867:1: rule__Reference__Group_1__1__Impl : ( ( rule__Reference__ComponentsAssignment_1_1 ) ) ;
    public final void rule__Reference__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7871:1: ( ( ( rule__Reference__ComponentsAssignment_1_1 ) ) )
            // InternalSolverLanguageParser.g:7872:1: ( ( rule__Reference__ComponentsAssignment_1_1 ) )
            {
            // InternalSolverLanguageParser.g:7872:1: ( ( rule__Reference__ComponentsAssignment_1_1 ) )
            // InternalSolverLanguageParser.g:7873:2: ( rule__Reference__ComponentsAssignment_1_1 )
            {
             before(grammarAccess.getReferenceAccess().getComponentsAssignment_1_1()); 
            // InternalSolverLanguageParser.g:7874:2: ( rule__Reference__ComponentsAssignment_1_1 )
            // InternalSolverLanguageParser.g:7874:3: rule__Reference__ComponentsAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__Reference__ComponentsAssignment_1_1();

            state._fsp--;


            }

             after(grammarAccess.getReferenceAccess().getComponentsAssignment_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__Group_1__1__Impl"


    // $ANTLR start "rule__PathComponent__Group__0"
    // InternalSolverLanguageParser.g:7883:1: rule__PathComponent__Group__0 : rule__PathComponent__Group__0__Impl rule__PathComponent__Group__1 ;
    public final void rule__PathComponent__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7887:1: ( rule__PathComponent__Group__0__Impl rule__PathComponent__Group__1 )
            // InternalSolverLanguageParser.g:7888:2: rule__PathComponent__Group__0__Impl rule__PathComponent__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__PathComponent__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PathComponent__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__Group__0"


    // $ANTLR start "rule__PathComponent__Group__0__Impl"
    // InternalSolverLanguageParser.g:7895:1: rule__PathComponent__Group__0__Impl : ( ( rule__PathComponent__InverseAssignment_0 )? ) ;
    public final void rule__PathComponent__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7899:1: ( ( ( rule__PathComponent__InverseAssignment_0 )? ) )
            // InternalSolverLanguageParser.g:7900:1: ( ( rule__PathComponent__InverseAssignment_0 )? )
            {
            // InternalSolverLanguageParser.g:7900:1: ( ( rule__PathComponent__InverseAssignment_0 )? )
            // InternalSolverLanguageParser.g:7901:2: ( rule__PathComponent__InverseAssignment_0 )?
            {
             before(grammarAccess.getPathComponentAccess().getInverseAssignment_0()); 
            // InternalSolverLanguageParser.g:7902:2: ( rule__PathComponent__InverseAssignment_0 )?
            int alt54=2;
            int LA54_0 = input.LA(1);

            if ( (LA54_0==Tilde) ) {
                alt54=1;
            }
            switch (alt54) {
                case 1 :
                    // InternalSolverLanguageParser.g:7902:3: rule__PathComponent__InverseAssignment_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PathComponent__InverseAssignment_0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getPathComponentAccess().getInverseAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__Group__0__Impl"


    // $ANTLR start "rule__PathComponent__Group__1"
    // InternalSolverLanguageParser.g:7910:1: rule__PathComponent__Group__1 : rule__PathComponent__Group__1__Impl rule__PathComponent__Group__2 ;
    public final void rule__PathComponent__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7914:1: ( rule__PathComponent__Group__1__Impl rule__PathComponent__Group__2 )
            // InternalSolverLanguageParser.g:7915:2: rule__PathComponent__Group__1__Impl rule__PathComponent__Group__2
            {
            pushFollow(FOLLOW_51);
            rule__PathComponent__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__PathComponent__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__Group__1"


    // $ANTLR start "rule__PathComponent__Group__1__Impl"
    // InternalSolverLanguageParser.g:7922:1: rule__PathComponent__Group__1__Impl : ( ( rule__PathComponent__SymbolAssignment_1 ) ) ;
    public final void rule__PathComponent__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7926:1: ( ( ( rule__PathComponent__SymbolAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:7927:1: ( ( rule__PathComponent__SymbolAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:7927:1: ( ( rule__PathComponent__SymbolAssignment_1 ) )
            // InternalSolverLanguageParser.g:7928:2: ( rule__PathComponent__SymbolAssignment_1 )
            {
             before(grammarAccess.getPathComponentAccess().getSymbolAssignment_1()); 
            // InternalSolverLanguageParser.g:7929:2: ( rule__PathComponent__SymbolAssignment_1 )
            // InternalSolverLanguageParser.g:7929:3: rule__PathComponent__SymbolAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__PathComponent__SymbolAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getPathComponentAccess().getSymbolAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__Group__1__Impl"


    // $ANTLR start "rule__PathComponent__Group__2"
    // InternalSolverLanguageParser.g:7937:1: rule__PathComponent__Group__2 : rule__PathComponent__Group__2__Impl ;
    public final void rule__PathComponent__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7941:1: ( rule__PathComponent__Group__2__Impl )
            // InternalSolverLanguageParser.g:7942:2: rule__PathComponent__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PathComponent__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__Group__2"


    // $ANTLR start "rule__PathComponent__Group__2__Impl"
    // InternalSolverLanguageParser.g:7948:1: rule__PathComponent__Group__2__Impl : ( ( rule__PathComponent__Alternatives_2 )? ) ;
    public final void rule__PathComponent__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7952:1: ( ( ( rule__PathComponent__Alternatives_2 )? ) )
            // InternalSolverLanguageParser.g:7953:1: ( ( rule__PathComponent__Alternatives_2 )? )
            {
            // InternalSolverLanguageParser.g:7953:1: ( ( rule__PathComponent__Alternatives_2 )? )
            // InternalSolverLanguageParser.g:7954:2: ( rule__PathComponent__Alternatives_2 )?
            {
             before(grammarAccess.getPathComponentAccess().getAlternatives_2()); 
            // InternalSolverLanguageParser.g:7955:2: ( rule__PathComponent__Alternatives_2 )?
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( ((LA55_0>=RULE_TRANSITIVE_CLOSURE && LA55_0<=RULE_REFLEXIVE_TRANSITIVE_CLOSURE)) ) {
                alt55=1;
            }
            switch (alt55) {
                case 1 :
                    // InternalSolverLanguageParser.g:7955:3: rule__PathComponent__Alternatives_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__PathComponent__Alternatives_2();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getPathComponentAccess().getAlternatives_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__Group__2__Impl"


    // $ANTLR start "rule__Interval__Group__0"
    // InternalSolverLanguageParser.g:7964:1: rule__Interval__Group__0 : rule__Interval__Group__0__Impl rule__Interval__Group__1 ;
    public final void rule__Interval__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7968:1: ( rule__Interval__Group__0__Impl rule__Interval__Group__1 )
            // InternalSolverLanguageParser.g:7969:2: rule__Interval__Group__0__Impl rule__Interval__Group__1
            {
            pushFollow(FOLLOW_12);
            rule__Interval__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Interval__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__0"


    // $ANTLR start "rule__Interval__Group__0__Impl"
    // InternalSolverLanguageParser.g:7976:1: rule__Interval__Group__0__Impl : ( LeftSquareBracket ) ;
    public final void rule__Interval__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7980:1: ( ( LeftSquareBracket ) )
            // InternalSolverLanguageParser.g:7981:1: ( LeftSquareBracket )
            {
            // InternalSolverLanguageParser.g:7981:1: ( LeftSquareBracket )
            // InternalSolverLanguageParser.g:7982:2: LeftSquareBracket
            {
             before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); 
            match(input,LeftSquareBracket,FOLLOW_2); 
             after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__0__Impl"


    // $ANTLR start "rule__Interval__Group__1"
    // InternalSolverLanguageParser.g:7991:1: rule__Interval__Group__1 : rule__Interval__Group__1__Impl rule__Interval__Group__2 ;
    public final void rule__Interval__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:7995:1: ( rule__Interval__Group__1__Impl rule__Interval__Group__2 )
            // InternalSolverLanguageParser.g:7996:2: rule__Interval__Group__1__Impl rule__Interval__Group__2
            {
            pushFollow(FOLLOW_35);
            rule__Interval__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Interval__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__1"


    // $ANTLR start "rule__Interval__Group__1__Impl"
    // InternalSolverLanguageParser.g:8003:1: rule__Interval__Group__1__Impl : ( ( rule__Interval__LowerBoundAssignment_1 ) ) ;
    public final void rule__Interval__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8007:1: ( ( ( rule__Interval__LowerBoundAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:8008:1: ( ( rule__Interval__LowerBoundAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:8008:1: ( ( rule__Interval__LowerBoundAssignment_1 ) )
            // InternalSolverLanguageParser.g:8009:2: ( rule__Interval__LowerBoundAssignment_1 )
            {
             before(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); 
            // InternalSolverLanguageParser.g:8010:2: ( rule__Interval__LowerBoundAssignment_1 )
            // InternalSolverLanguageParser.g:8010:3: rule__Interval__LowerBoundAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__Interval__LowerBoundAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__1__Impl"


    // $ANTLR start "rule__Interval__Group__2"
    // InternalSolverLanguageParser.g:8018:1: rule__Interval__Group__2 : rule__Interval__Group__2__Impl rule__Interval__Group__3 ;
    public final void rule__Interval__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8022:1: ( rule__Interval__Group__2__Impl rule__Interval__Group__3 )
            // InternalSolverLanguageParser.g:8023:2: rule__Interval__Group__2__Impl rule__Interval__Group__3
            {
            pushFollow(FOLLOW_12);
            rule__Interval__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Interval__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__2"


    // $ANTLR start "rule__Interval__Group__2__Impl"
    // InternalSolverLanguageParser.g:8030:1: rule__Interval__Group__2__Impl : ( Comma ) ;
    public final void rule__Interval__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8034:1: ( ( Comma ) )
            // InternalSolverLanguageParser.g:8035:1: ( Comma )
            {
            // InternalSolverLanguageParser.g:8035:1: ( Comma )
            // InternalSolverLanguageParser.g:8036:2: Comma
            {
             before(grammarAccess.getIntervalAccess().getCommaKeyword_2()); 
            match(input,Comma,FOLLOW_2); 
             after(grammarAccess.getIntervalAccess().getCommaKeyword_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__2__Impl"


    // $ANTLR start "rule__Interval__Group__3"
    // InternalSolverLanguageParser.g:8045:1: rule__Interval__Group__3 : rule__Interval__Group__3__Impl rule__Interval__Group__4 ;
    public final void rule__Interval__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8049:1: ( rule__Interval__Group__3__Impl rule__Interval__Group__4 )
            // InternalSolverLanguageParser.g:8050:2: rule__Interval__Group__3__Impl rule__Interval__Group__4
            {
            pushFollow(FOLLOW_52);
            rule__Interval__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Interval__Group__4();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__3"


    // $ANTLR start "rule__Interval__Group__3__Impl"
    // InternalSolverLanguageParser.g:8057:1: rule__Interval__Group__3__Impl : ( ( rule__Interval__UpperBoundAssignment_3 ) ) ;
    public final void rule__Interval__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8061:1: ( ( ( rule__Interval__UpperBoundAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:8062:1: ( ( rule__Interval__UpperBoundAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:8062:1: ( ( rule__Interval__UpperBoundAssignment_3 ) )
            // InternalSolverLanguageParser.g:8063:2: ( rule__Interval__UpperBoundAssignment_3 )
            {
             before(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); 
            // InternalSolverLanguageParser.g:8064:2: ( rule__Interval__UpperBoundAssignment_3 )
            // InternalSolverLanguageParser.g:8064:3: rule__Interval__UpperBoundAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__Interval__UpperBoundAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__3__Impl"


    // $ANTLR start "rule__Interval__Group__4"
    // InternalSolverLanguageParser.g:8072:1: rule__Interval__Group__4 : rule__Interval__Group__4__Impl ;
    public final void rule__Interval__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8076:1: ( rule__Interval__Group__4__Impl )
            // InternalSolverLanguageParser.g:8077:2: rule__Interval__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Interval__Group__4__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__4"


    // $ANTLR start "rule__Interval__Group__4__Impl"
    // InternalSolverLanguageParser.g:8083:1: rule__Interval__Group__4__Impl : ( RightSquareBracket ) ;
    public final void rule__Interval__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8087:1: ( ( RightSquareBracket ) )
            // InternalSolverLanguageParser.g:8088:1: ( RightSquareBracket )
            {
            // InternalSolverLanguageParser.g:8088:1: ( RightSquareBracket )
            // InternalSolverLanguageParser.g:8089:2: RightSquareBracket
            {
             before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); 
            match(input,RightSquareBracket,FOLLOW_2); 
             after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__Group__4__Impl"


    // $ANTLR start "rule__InfinityLiteral__Group__0"
    // InternalSolverLanguageParser.g:8099:1: rule__InfinityLiteral__Group__0 : rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 ;
    public final void rule__InfinityLiteral__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8103:1: ( rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 )
            // InternalSolverLanguageParser.g:8104:2: rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1
            {
            pushFollow(FOLLOW_53);
            rule__InfinityLiteral__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__InfinityLiteral__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InfinityLiteral__Group__0"


    // $ANTLR start "rule__InfinityLiteral__Group__0__Impl"
    // InternalSolverLanguageParser.g:8111:1: rule__InfinityLiteral__Group__0__Impl : ( () ) ;
    public final void rule__InfinityLiteral__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8115:1: ( ( () ) )
            // InternalSolverLanguageParser.g:8116:1: ( () )
            {
            // InternalSolverLanguageParser.g:8116:1: ( () )
            // InternalSolverLanguageParser.g:8117:2: ()
            {
             before(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); 
            // InternalSolverLanguageParser.g:8118:2: ()
            // InternalSolverLanguageParser.g:8118:3: 
            {
            }

             after(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InfinityLiteral__Group__0__Impl"


    // $ANTLR start "rule__InfinityLiteral__Group__1"
    // InternalSolverLanguageParser.g:8126:1: rule__InfinityLiteral__Group__1 : rule__InfinityLiteral__Group__1__Impl ;
    public final void rule__InfinityLiteral__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8130:1: ( rule__InfinityLiteral__Group__1__Impl )
            // InternalSolverLanguageParser.g:8131:2: rule__InfinityLiteral__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InfinityLiteral__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InfinityLiteral__Group__1"


    // $ANTLR start "rule__InfinityLiteral__Group__1__Impl"
    // InternalSolverLanguageParser.g:8137:1: rule__InfinityLiteral__Group__1__Impl : ( Inf ) ;
    public final void rule__InfinityLiteral__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8141:1: ( ( Inf ) )
            // InternalSolverLanguageParser.g:8142:1: ( Inf )
            {
            // InternalSolverLanguageParser.g:8142:1: ( Inf )
            // InternalSolverLanguageParser.g:8143:2: Inf
            {
             before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); 
            match(input,Inf,FOLLOW_2); 
             after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InfinityLiteral__Group__1__Impl"


    // $ANTLR start "rule__EmptyLiteral__Group__0"
    // InternalSolverLanguageParser.g:8153:1: rule__EmptyLiteral__Group__0 : rule__EmptyLiteral__Group__0__Impl rule__EmptyLiteral__Group__1 ;
    public final void rule__EmptyLiteral__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8157:1: ( rule__EmptyLiteral__Group__0__Impl rule__EmptyLiteral__Group__1 )
            // InternalSolverLanguageParser.g:8158:2: rule__EmptyLiteral__Group__0__Impl rule__EmptyLiteral__Group__1
            {
            pushFollow(FOLLOW_54);
            rule__EmptyLiteral__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EmptyLiteral__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EmptyLiteral__Group__0"


    // $ANTLR start "rule__EmptyLiteral__Group__0__Impl"
    // InternalSolverLanguageParser.g:8165:1: rule__EmptyLiteral__Group__0__Impl : ( () ) ;
    public final void rule__EmptyLiteral__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8169:1: ( ( () ) )
            // InternalSolverLanguageParser.g:8170:1: ( () )
            {
            // InternalSolverLanguageParser.g:8170:1: ( () )
            // InternalSolverLanguageParser.g:8171:2: ()
            {
             before(grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0()); 
            // InternalSolverLanguageParser.g:8172:2: ()
            // InternalSolverLanguageParser.g:8172:3: 
            {
            }

             after(grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EmptyLiteral__Group__0__Impl"


    // $ANTLR start "rule__EmptyLiteral__Group__1"
    // InternalSolverLanguageParser.g:8180:1: rule__EmptyLiteral__Group__1 : rule__EmptyLiteral__Group__1__Impl ;
    public final void rule__EmptyLiteral__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8184:1: ( rule__EmptyLiteral__Group__1__Impl )
            // InternalSolverLanguageParser.g:8185:2: rule__EmptyLiteral__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EmptyLiteral__Group__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EmptyLiteral__Group__1"


    // $ANTLR start "rule__EmptyLiteral__Group__1__Impl"
    // InternalSolverLanguageParser.g:8191:1: rule__EmptyLiteral__Group__1__Impl : ( Empty ) ;
    public final void rule__EmptyLiteral__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8195:1: ( ( Empty ) )
            // InternalSolverLanguageParser.g:8196:1: ( Empty )
            {
            // InternalSolverLanguageParser.g:8196:1: ( Empty )
            // InternalSolverLanguageParser.g:8197:2: Empty
            {
             before(grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); 
            match(input,Empty,FOLLOW_2); 
             after(grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EmptyLiteral__Group__1__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group__0"
    // InternalSolverLanguageParser.g:8207:1: rule__ClassDeclaration__Group__0 : rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ;
    public final void rule__ClassDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8211:1: ( rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:8212:2: rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1
            {
            pushFollow(FOLLOW_55);
            rule__ClassDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__0"


    // $ANTLR start "rule__ClassDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:8219:1: rule__ClassDeclaration__Group__0__Impl : ( ( rule__ClassDeclaration__UnorderedGroup_0 ) ) ;
    public final void rule__ClassDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8223:1: ( ( ( rule__ClassDeclaration__UnorderedGroup_0 ) ) )
            // InternalSolverLanguageParser.g:8224:1: ( ( rule__ClassDeclaration__UnorderedGroup_0 ) )
            {
            // InternalSolverLanguageParser.g:8224:1: ( ( rule__ClassDeclaration__UnorderedGroup_0 ) )
            // InternalSolverLanguageParser.g:8225:2: ( rule__ClassDeclaration__UnorderedGroup_0 )
            {
             before(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); 
            // InternalSolverLanguageParser.g:8226:2: ( rule__ClassDeclaration__UnorderedGroup_0 )
            // InternalSolverLanguageParser.g:8226:3: rule__ClassDeclaration__UnorderedGroup_0
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__UnorderedGroup_0();

            state._fsp--;


            }

             after(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__0__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group__1"
    // InternalSolverLanguageParser.g:8234:1: rule__ClassDeclaration__Group__1 : rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ;
    public final void rule__ClassDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8238:1: ( rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:8239:2: rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2
            {
            pushFollow(FOLLOW_48);
            rule__ClassDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__1"


    // $ANTLR start "rule__ClassDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:8246:1: rule__ClassDeclaration__Group__1__Impl : ( Class ) ;
    public final void rule__ClassDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8250:1: ( ( Class ) )
            // InternalSolverLanguageParser.g:8251:1: ( Class )
            {
            // InternalSolverLanguageParser.g:8251:1: ( Class )
            // InternalSolverLanguageParser.g:8252:2: Class
            {
             before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); 
            match(input,Class,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__1__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group__2"
    // InternalSolverLanguageParser.g:8261:1: rule__ClassDeclaration__Group__2 : rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ;
    public final void rule__ClassDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8265:1: ( rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 )
            // InternalSolverLanguageParser.g:8266:2: rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3
            {
            pushFollow(FOLLOW_56);
            rule__ClassDeclaration__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__2"


    // $ANTLR start "rule__ClassDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:8273:1: rule__ClassDeclaration__Group__2__Impl : ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ;
    public final void rule__ClassDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8277:1: ( ( ( rule__ClassDeclaration__NameAssignment_2 ) ) )
            // InternalSolverLanguageParser.g:8278:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) )
            {
            // InternalSolverLanguageParser.g:8278:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) )
            // InternalSolverLanguageParser.g:8279:2: ( rule__ClassDeclaration__NameAssignment_2 )
            {
             before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); 
            // InternalSolverLanguageParser.g:8280:2: ( rule__ClassDeclaration__NameAssignment_2 )
            // InternalSolverLanguageParser.g:8280:3: rule__ClassDeclaration__NameAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__NameAssignment_2();

            state._fsp--;


            }

             after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__2__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group__3"
    // InternalSolverLanguageParser.g:8288:1: rule__ClassDeclaration__Group__3 : rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ;
    public final void rule__ClassDeclaration__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8292:1: ( rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 )
            // InternalSolverLanguageParser.g:8293:2: rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4
            {
            pushFollow(FOLLOW_56);
            rule__ClassDeclaration__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group__4();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__3"


    // $ANTLR start "rule__ClassDeclaration__Group__3__Impl"
    // InternalSolverLanguageParser.g:8300:1: rule__ClassDeclaration__Group__3__Impl : ( ( rule__ClassDeclaration__Group_3__0 )? ) ;
    public final void rule__ClassDeclaration__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8304:1: ( ( ( rule__ClassDeclaration__Group_3__0 )? ) )
            // InternalSolverLanguageParser.g:8305:1: ( ( rule__ClassDeclaration__Group_3__0 )? )
            {
            // InternalSolverLanguageParser.g:8305:1: ( ( rule__ClassDeclaration__Group_3__0 )? )
            // InternalSolverLanguageParser.g:8306:2: ( rule__ClassDeclaration__Group_3__0 )?
            {
             before(grammarAccess.getClassDeclarationAccess().getGroup_3()); 
            // InternalSolverLanguageParser.g:8307:2: ( rule__ClassDeclaration__Group_3__0 )?
            int alt56=2;
            int LA56_0 = input.LA(1);

            if ( (LA56_0==Extends) ) {
                alt56=1;
            }
            switch (alt56) {
                case 1 :
                    // InternalSolverLanguageParser.g:8307:3: rule__ClassDeclaration__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassDeclaration__Group_3__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getClassDeclarationAccess().getGroup_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__3__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group__4"
    // InternalSolverLanguageParser.g:8315:1: rule__ClassDeclaration__Group__4 : rule__ClassDeclaration__Group__4__Impl ;
    public final void rule__ClassDeclaration__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8319:1: ( rule__ClassDeclaration__Group__4__Impl )
            // InternalSolverLanguageParser.g:8320:2: rule__ClassDeclaration__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group__4__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__4"


    // $ANTLR start "rule__ClassDeclaration__Group__4__Impl"
    // InternalSolverLanguageParser.g:8326:1: rule__ClassDeclaration__Group__4__Impl : ( ( rule__ClassDeclaration__Alternatives_4 ) ) ;
    public final void rule__ClassDeclaration__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8330:1: ( ( ( rule__ClassDeclaration__Alternatives_4 ) ) )
            // InternalSolverLanguageParser.g:8331:1: ( ( rule__ClassDeclaration__Alternatives_4 ) )
            {
            // InternalSolverLanguageParser.g:8331:1: ( ( rule__ClassDeclaration__Alternatives_4 ) )
            // InternalSolverLanguageParser.g:8332:2: ( rule__ClassDeclaration__Alternatives_4 )
            {
             before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); 
            // InternalSolverLanguageParser.g:8333:2: ( rule__ClassDeclaration__Alternatives_4 )
            // InternalSolverLanguageParser.g:8333:3: rule__ClassDeclaration__Alternatives_4
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Alternatives_4();

            state._fsp--;


            }

             after(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group__4__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_3__0"
    // InternalSolverLanguageParser.g:8342:1: rule__ClassDeclaration__Group_3__0 : rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ;
    public final void rule__ClassDeclaration__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8346:1: ( rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 )
            // InternalSolverLanguageParser.g:8347:2: rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1
            {
            pushFollow(FOLLOW_6);
            rule__ClassDeclaration__Group_3__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_3__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3__0"


    // $ANTLR start "rule__ClassDeclaration__Group_3__0__Impl"
    // InternalSolverLanguageParser.g:8354:1: rule__ClassDeclaration__Group_3__0__Impl : ( Extends ) ;
    public final void rule__ClassDeclaration__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8358:1: ( ( Extends ) )
            // InternalSolverLanguageParser.g:8359:1: ( Extends )
            {
            // InternalSolverLanguageParser.g:8359:1: ( Extends )
            // InternalSolverLanguageParser.g:8360:2: Extends
            {
             before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); 
            match(input,Extends,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3__0__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_3__1"
    // InternalSolverLanguageParser.g:8369:1: rule__ClassDeclaration__Group_3__1 : rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ;
    public final void rule__ClassDeclaration__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8373:1: ( rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 )
            // InternalSolverLanguageParser.g:8374:2: rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2
            {
            pushFollow(FOLLOW_35);
            rule__ClassDeclaration__Group_3__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_3__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3__1"


    // $ANTLR start "rule__ClassDeclaration__Group_3__1__Impl"
    // InternalSolverLanguageParser.g:8381:1: rule__ClassDeclaration__Group_3__1__Impl : ( ( rule__ClassDeclaration__SupertypesAssignment_3_1 ) ) ;
    public final void rule__ClassDeclaration__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8385:1: ( ( ( rule__ClassDeclaration__SupertypesAssignment_3_1 ) ) )
            // InternalSolverLanguageParser.g:8386:1: ( ( rule__ClassDeclaration__SupertypesAssignment_3_1 ) )
            {
            // InternalSolverLanguageParser.g:8386:1: ( ( rule__ClassDeclaration__SupertypesAssignment_3_1 ) )
            // InternalSolverLanguageParser.g:8387:2: ( rule__ClassDeclaration__SupertypesAssignment_3_1 )
            {
             before(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_1()); 
            // InternalSolverLanguageParser.g:8388:2: ( rule__ClassDeclaration__SupertypesAssignment_3_1 )
            // InternalSolverLanguageParser.g:8388:3: rule__ClassDeclaration__SupertypesAssignment_3_1
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__SupertypesAssignment_3_1();

            state._fsp--;


            }

             after(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3__1__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_3__2"
    // InternalSolverLanguageParser.g:8396:1: rule__ClassDeclaration__Group_3__2 : rule__ClassDeclaration__Group_3__2__Impl ;
    public final void rule__ClassDeclaration__Group_3__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8400:1: ( rule__ClassDeclaration__Group_3__2__Impl )
            // InternalSolverLanguageParser.g:8401:2: rule__ClassDeclaration__Group_3__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_3__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3__2"


    // $ANTLR start "rule__ClassDeclaration__Group_3__2__Impl"
    // InternalSolverLanguageParser.g:8407:1: rule__ClassDeclaration__Group_3__2__Impl : ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ;
    public final void rule__ClassDeclaration__Group_3__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8411:1: ( ( ( rule__ClassDeclaration__Group_3_2__0 )* ) )
            // InternalSolverLanguageParser.g:8412:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* )
            {
            // InternalSolverLanguageParser.g:8412:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* )
            // InternalSolverLanguageParser.g:8413:2: ( rule__ClassDeclaration__Group_3_2__0 )*
            {
             before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); 
            // InternalSolverLanguageParser.g:8414:2: ( rule__ClassDeclaration__Group_3_2__0 )*
            loop57:
            do {
                int alt57=2;
                int LA57_0 = input.LA(1);

                if ( (LA57_0==Comma) ) {
                    alt57=1;
                }


                switch (alt57) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:8414:3: rule__ClassDeclaration__Group_3_2__0
            	    {
            	    pushFollow(FOLLOW_29);
            	    rule__ClassDeclaration__Group_3_2__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop57;
                }
            } while (true);

             after(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3__2__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_3_2__0"
    // InternalSolverLanguageParser.g:8423:1: rule__ClassDeclaration__Group_3_2__0 : rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ;
    public final void rule__ClassDeclaration__Group_3_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8427:1: ( rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 )
            // InternalSolverLanguageParser.g:8428:2: rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1
            {
            pushFollow(FOLLOW_6);
            rule__ClassDeclaration__Group_3_2__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_3_2__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3_2__0"


    // $ANTLR start "rule__ClassDeclaration__Group_3_2__0__Impl"
    // InternalSolverLanguageParser.g:8435:1: rule__ClassDeclaration__Group_3_2__0__Impl : ( Comma ) ;
    public final void rule__ClassDeclaration__Group_3_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8439:1: ( ( Comma ) )
            // InternalSolverLanguageParser.g:8440:1: ( Comma )
            {
            // InternalSolverLanguageParser.g:8440:1: ( Comma )
            // InternalSolverLanguageParser.g:8441:2: Comma
            {
             before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); 
            match(input,Comma,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3_2__0__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_3_2__1"
    // InternalSolverLanguageParser.g:8450:1: rule__ClassDeclaration__Group_3_2__1 : rule__ClassDeclaration__Group_3_2__1__Impl ;
    public final void rule__ClassDeclaration__Group_3_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8454:1: ( rule__ClassDeclaration__Group_3_2__1__Impl )
            // InternalSolverLanguageParser.g:8455:2: rule__ClassDeclaration__Group_3_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_3_2__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3_2__1"


    // $ANTLR start "rule__ClassDeclaration__Group_3_2__1__Impl"
    // InternalSolverLanguageParser.g:8461:1: rule__ClassDeclaration__Group_3_2__1__Impl : ( ( rule__ClassDeclaration__SupertypesAssignment_3_2_1 ) ) ;
    public final void rule__ClassDeclaration__Group_3_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8465:1: ( ( ( rule__ClassDeclaration__SupertypesAssignment_3_2_1 ) ) )
            // InternalSolverLanguageParser.g:8466:1: ( ( rule__ClassDeclaration__SupertypesAssignment_3_2_1 ) )
            {
            // InternalSolverLanguageParser.g:8466:1: ( ( rule__ClassDeclaration__SupertypesAssignment_3_2_1 ) )
            // InternalSolverLanguageParser.g:8467:2: ( rule__ClassDeclaration__SupertypesAssignment_3_2_1 )
            {
             before(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_2_1()); 
            // InternalSolverLanguageParser.g:8468:2: ( rule__ClassDeclaration__SupertypesAssignment_3_2_1 )
            // InternalSolverLanguageParser.g:8468:3: rule__ClassDeclaration__SupertypesAssignment_3_2_1
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__SupertypesAssignment_3_2_1();

            state._fsp--;


            }

             after(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_2_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_3_2__1__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_4_0__0"
    // InternalSolverLanguageParser.g:8477:1: rule__ClassDeclaration__Group_4_0__0 : rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ;
    public final void rule__ClassDeclaration__Group_4_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8481:1: ( rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 )
            // InternalSolverLanguageParser.g:8482:2: rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1
            {
            pushFollow(FOLLOW_57);
            rule__ClassDeclaration__Group_4_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_4_0__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_4_0__0"


    // $ANTLR start "rule__ClassDeclaration__Group_4_0__0__Impl"
    // InternalSolverLanguageParser.g:8489:1: rule__ClassDeclaration__Group_4_0__0__Impl : ( LeftCurlyBracket ) ;
    public final void rule__ClassDeclaration__Group_4_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8493:1: ( ( LeftCurlyBracket ) )
            // InternalSolverLanguageParser.g:8494:1: ( LeftCurlyBracket )
            {
            // InternalSolverLanguageParser.g:8494:1: ( LeftCurlyBracket )
            // InternalSolverLanguageParser.g:8495:2: LeftCurlyBracket
            {
             before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); 
            match(input,LeftCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_4_0__0__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_4_0__1"
    // InternalSolverLanguageParser.g:8504:1: rule__ClassDeclaration__Group_4_0__1 : rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ;
    public final void rule__ClassDeclaration__Group_4_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8508:1: ( rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 )
            // InternalSolverLanguageParser.g:8509:2: rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2
            {
            pushFollow(FOLLOW_57);
            rule__ClassDeclaration__Group_4_0__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_4_0__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_4_0__1"


    // $ANTLR start "rule__ClassDeclaration__Group_4_0__1__Impl"
    // InternalSolverLanguageParser.g:8516:1: rule__ClassDeclaration__Group_4_0__1__Impl : ( ( rule__ClassDeclaration__FieldsAssignment_4_0_1 )* ) ;
    public final void rule__ClassDeclaration__Group_4_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8520:1: ( ( ( rule__ClassDeclaration__FieldsAssignment_4_0_1 )* ) )
            // InternalSolverLanguageParser.g:8521:1: ( ( rule__ClassDeclaration__FieldsAssignment_4_0_1 )* )
            {
            // InternalSolverLanguageParser.g:8521:1: ( ( rule__ClassDeclaration__FieldsAssignment_4_0_1 )* )
            // InternalSolverLanguageParser.g:8522:2: ( rule__ClassDeclaration__FieldsAssignment_4_0_1 )*
            {
             before(grammarAccess.getClassDeclarationAccess().getFieldsAssignment_4_0_1()); 
            // InternalSolverLanguageParser.g:8523:2: ( rule__ClassDeclaration__FieldsAssignment_4_0_1 )*
            loop58:
            do {
                int alt58=2;
                int LA58_0 = input.LA(1);

                if ( (LA58_0==Contains||(LA58_0>=Object && LA58_0<=Refers)||LA58_0==RULE_QUOTED_ID||LA58_0==RULE_ID) ) {
                    alt58=1;
                }


                switch (alt58) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:8523:3: rule__ClassDeclaration__FieldsAssignment_4_0_1
            	    {
            	    pushFollow(FOLLOW_58);
            	    rule__ClassDeclaration__FieldsAssignment_4_0_1();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop58;
                }
            } while (true);

             after(grammarAccess.getClassDeclarationAccess().getFieldsAssignment_4_0_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_4_0__1__Impl"


    // $ANTLR start "rule__ClassDeclaration__Group_4_0__2"
    // InternalSolverLanguageParser.g:8531:1: rule__ClassDeclaration__Group_4_0__2 : rule__ClassDeclaration__Group_4_0__2__Impl ;
    public final void rule__ClassDeclaration__Group_4_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8535:1: ( rule__ClassDeclaration__Group_4_0__2__Impl )
            // InternalSolverLanguageParser.g:8536:2: rule__ClassDeclaration__Group_4_0__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__Group_4_0__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_4_0__2"


    // $ANTLR start "rule__ClassDeclaration__Group_4_0__2__Impl"
    // InternalSolverLanguageParser.g:8542:1: rule__ClassDeclaration__Group_4_0__2__Impl : ( RightCurlyBracket ) ;
    public final void rule__ClassDeclaration__Group_4_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8546:1: ( ( RightCurlyBracket ) )
            // InternalSolverLanguageParser.g:8547:1: ( RightCurlyBracket )
            {
            // InternalSolverLanguageParser.g:8547:1: ( RightCurlyBracket )
            // InternalSolverLanguageParser.g:8548:2: RightCurlyBracket
            {
             before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); 
            match(input,RightCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__Group_4_0__2__Impl"


    // $ANTLR start "rule__Field__Group__0"
    // InternalSolverLanguageParser.g:8558:1: rule__Field__Group__0 : rule__Field__Group__0__Impl rule__Field__Group__1 ;
    public final void rule__Field__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8562:1: ( rule__Field__Group__0__Impl rule__Field__Group__1 )
            // InternalSolverLanguageParser.g:8563:2: rule__Field__Group__0__Impl rule__Field__Group__1
            {
            pushFollow(FOLLOW_59);
            rule__Field__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Field__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__0"


    // $ANTLR start "rule__Field__Group__0__Impl"
    // InternalSolverLanguageParser.g:8570:1: rule__Field__Group__0__Impl : ( ( rule__Field__Alternatives_0 )? ) ;
    public final void rule__Field__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8574:1: ( ( ( rule__Field__Alternatives_0 )? ) )
            // InternalSolverLanguageParser.g:8575:1: ( ( rule__Field__Alternatives_0 )? )
            {
            // InternalSolverLanguageParser.g:8575:1: ( ( rule__Field__Alternatives_0 )? )
            // InternalSolverLanguageParser.g:8576:2: ( rule__Field__Alternatives_0 )?
            {
             before(grammarAccess.getFieldAccess().getAlternatives_0()); 
            // InternalSolverLanguageParser.g:8577:2: ( rule__Field__Alternatives_0 )?
            int alt59=2;
            int LA59_0 = input.LA(1);

            if ( (LA59_0==Contains||LA59_0==Refers) ) {
                alt59=1;
            }
            switch (alt59) {
                case 1 :
                    // InternalSolverLanguageParser.g:8577:3: rule__Field__Alternatives_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__Field__Alternatives_0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getFieldAccess().getAlternatives_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__0__Impl"


    // $ANTLR start "rule__Field__Group__1"
    // InternalSolverLanguageParser.g:8585:1: rule__Field__Group__1 : rule__Field__Group__1__Impl rule__Field__Group__2 ;
    public final void rule__Field__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8589:1: ( rule__Field__Group__1__Impl rule__Field__Group__2 )
            // InternalSolverLanguageParser.g:8590:2: rule__Field__Group__1__Impl rule__Field__Group__2
            {
            pushFollow(FOLLOW_60);
            rule__Field__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Field__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__1"


    // $ANTLR start "rule__Field__Group__1__Impl"
    // InternalSolverLanguageParser.g:8597:1: rule__Field__Group__1__Impl : ( ( rule__Field__TypeAssignment_1 ) ) ;
    public final void rule__Field__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8601:1: ( ( ( rule__Field__TypeAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:8602:1: ( ( rule__Field__TypeAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:8602:1: ( ( rule__Field__TypeAssignment_1 ) )
            // InternalSolverLanguageParser.g:8603:2: ( rule__Field__TypeAssignment_1 )
            {
             before(grammarAccess.getFieldAccess().getTypeAssignment_1()); 
            // InternalSolverLanguageParser.g:8604:2: ( rule__Field__TypeAssignment_1 )
            // InternalSolverLanguageParser.g:8604:3: rule__Field__TypeAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__Field__TypeAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getFieldAccess().getTypeAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__1__Impl"


    // $ANTLR start "rule__Field__Group__2"
    // InternalSolverLanguageParser.g:8612:1: rule__Field__Group__2 : rule__Field__Group__2__Impl rule__Field__Group__3 ;
    public final void rule__Field__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8616:1: ( rule__Field__Group__2__Impl rule__Field__Group__3 )
            // InternalSolverLanguageParser.g:8617:2: rule__Field__Group__2__Impl rule__Field__Group__3
            {
            pushFollow(FOLLOW_60);
            rule__Field__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Field__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__2"


    // $ANTLR start "rule__Field__Group__2__Impl"
    // InternalSolverLanguageParser.g:8624:1: rule__Field__Group__2__Impl : ( ( rule__Field__MultiplicityAssignment_2 )? ) ;
    public final void rule__Field__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8628:1: ( ( ( rule__Field__MultiplicityAssignment_2 )? ) )
            // InternalSolverLanguageParser.g:8629:1: ( ( rule__Field__MultiplicityAssignment_2 )? )
            {
            // InternalSolverLanguageParser.g:8629:1: ( ( rule__Field__MultiplicityAssignment_2 )? )
            // InternalSolverLanguageParser.g:8630:2: ( rule__Field__MultiplicityAssignment_2 )?
            {
             before(grammarAccess.getFieldAccess().getMultiplicityAssignment_2()); 
            // InternalSolverLanguageParser.g:8631:2: ( rule__Field__MultiplicityAssignment_2 )?
            int alt60=2;
            int LA60_0 = input.LA(1);

            if ( (LA60_0==LeftSquareBracket) ) {
                alt60=1;
            }
            switch (alt60) {
                case 1 :
                    // InternalSolverLanguageParser.g:8631:3: rule__Field__MultiplicityAssignment_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__Field__MultiplicityAssignment_2();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getFieldAccess().getMultiplicityAssignment_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__2__Impl"


    // $ANTLR start "rule__Field__Group__3"
    // InternalSolverLanguageParser.g:8639:1: rule__Field__Group__3 : rule__Field__Group__3__Impl rule__Field__Group__4 ;
    public final void rule__Field__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8643:1: ( rule__Field__Group__3__Impl rule__Field__Group__4 )
            // InternalSolverLanguageParser.g:8644:2: rule__Field__Group__3__Impl rule__Field__Group__4
            {
            pushFollow(FOLLOW_61);
            rule__Field__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Field__Group__4();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__3"


    // $ANTLR start "rule__Field__Group__3__Impl"
    // InternalSolverLanguageParser.g:8651:1: rule__Field__Group__3__Impl : ( ( rule__Field__NameAssignment_3 ) ) ;
    public final void rule__Field__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8655:1: ( ( ( rule__Field__NameAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:8656:1: ( ( rule__Field__NameAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:8656:1: ( ( rule__Field__NameAssignment_3 ) )
            // InternalSolverLanguageParser.g:8657:2: ( rule__Field__NameAssignment_3 )
            {
             before(grammarAccess.getFieldAccess().getNameAssignment_3()); 
            // InternalSolverLanguageParser.g:8658:2: ( rule__Field__NameAssignment_3 )
            // InternalSolverLanguageParser.g:8658:3: rule__Field__NameAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__Field__NameAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getFieldAccess().getNameAssignment_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__3__Impl"


    // $ANTLR start "rule__Field__Group__4"
    // InternalSolverLanguageParser.g:8666:1: rule__Field__Group__4 : rule__Field__Group__4__Impl rule__Field__Group__5 ;
    public final void rule__Field__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8670:1: ( rule__Field__Group__4__Impl rule__Field__Group__5 )
            // InternalSolverLanguageParser.g:8671:2: rule__Field__Group__4__Impl rule__Field__Group__5
            {
            pushFollow(FOLLOW_61);
            rule__Field__Group__4__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Field__Group__5();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__4"


    // $ANTLR start "rule__Field__Group__4__Impl"
    // InternalSolverLanguageParser.g:8678:1: rule__Field__Group__4__Impl : ( ( rule__Field__Group_4__0 )? ) ;
    public final void rule__Field__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8682:1: ( ( ( rule__Field__Group_4__0 )? ) )
            // InternalSolverLanguageParser.g:8683:1: ( ( rule__Field__Group_4__0 )? )
            {
            // InternalSolverLanguageParser.g:8683:1: ( ( rule__Field__Group_4__0 )? )
            // InternalSolverLanguageParser.g:8684:2: ( rule__Field__Group_4__0 )?
            {
             before(grammarAccess.getFieldAccess().getGroup_4()); 
            // InternalSolverLanguageParser.g:8685:2: ( rule__Field__Group_4__0 )?
            int alt61=2;
            int LA61_0 = input.LA(1);

            if ( (LA61_0==Opposite) ) {
                alt61=1;
            }
            switch (alt61) {
                case 1 :
                    // InternalSolverLanguageParser.g:8685:3: rule__Field__Group_4__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__Field__Group_4__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getFieldAccess().getGroup_4()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__4__Impl"


    // $ANTLR start "rule__Field__Group__5"
    // InternalSolverLanguageParser.g:8693:1: rule__Field__Group__5 : rule__Field__Group__5__Impl ;
    public final void rule__Field__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8697:1: ( rule__Field__Group__5__Impl )
            // InternalSolverLanguageParser.g:8698:2: rule__Field__Group__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Field__Group__5__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__5"


    // $ANTLR start "rule__Field__Group__5__Impl"
    // InternalSolverLanguageParser.g:8704:1: rule__Field__Group__5__Impl : ( ( Semicolon )? ) ;
    public final void rule__Field__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8708:1: ( ( ( Semicolon )? ) )
            // InternalSolverLanguageParser.g:8709:1: ( ( Semicolon )? )
            {
            // InternalSolverLanguageParser.g:8709:1: ( ( Semicolon )? )
            // InternalSolverLanguageParser.g:8710:2: ( Semicolon )?
            {
             before(grammarAccess.getFieldAccess().getSemicolonKeyword_5()); 
            // InternalSolverLanguageParser.g:8711:2: ( Semicolon )?
            int alt62=2;
            int LA62_0 = input.LA(1);

            if ( (LA62_0==Semicolon) ) {
                alt62=1;
            }
            switch (alt62) {
                case 1 :
                    // InternalSolverLanguageParser.g:8711:3: Semicolon
                    {
                    match(input,Semicolon,FOLLOW_2); 

                    }
                    break;

            }

             after(grammarAccess.getFieldAccess().getSemicolonKeyword_5()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group__5__Impl"


    // $ANTLR start "rule__Field__Group_4__0"
    // InternalSolverLanguageParser.g:8720:1: rule__Field__Group_4__0 : rule__Field__Group_4__0__Impl rule__Field__Group_4__1 ;
    public final void rule__Field__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8724:1: ( rule__Field__Group_4__0__Impl rule__Field__Group_4__1 )
            // InternalSolverLanguageParser.g:8725:2: rule__Field__Group_4__0__Impl rule__Field__Group_4__1
            {
            pushFollow(FOLLOW_6);
            rule__Field__Group_4__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Field__Group_4__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group_4__0"


    // $ANTLR start "rule__Field__Group_4__0__Impl"
    // InternalSolverLanguageParser.g:8732:1: rule__Field__Group_4__0__Impl : ( Opposite ) ;
    public final void rule__Field__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8736:1: ( ( Opposite ) )
            // InternalSolverLanguageParser.g:8737:1: ( Opposite )
            {
            // InternalSolverLanguageParser.g:8737:1: ( Opposite )
            // InternalSolverLanguageParser.g:8738:2: Opposite
            {
             before(grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); 
            match(input,Opposite,FOLLOW_2); 
             after(grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group_4__0__Impl"


    // $ANTLR start "rule__Field__Group_4__1"
    // InternalSolverLanguageParser.g:8747:1: rule__Field__Group_4__1 : rule__Field__Group_4__1__Impl ;
    public final void rule__Field__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8751:1: ( rule__Field__Group_4__1__Impl )
            // InternalSolverLanguageParser.g:8752:2: rule__Field__Group_4__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Field__Group_4__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group_4__1"


    // $ANTLR start "rule__Field__Group_4__1__Impl"
    // InternalSolverLanguageParser.g:8758:1: rule__Field__Group_4__1__Impl : ( ( rule__Field__OppositeAssignment_4_1 ) ) ;
    public final void rule__Field__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8762:1: ( ( ( rule__Field__OppositeAssignment_4_1 ) ) )
            // InternalSolverLanguageParser.g:8763:1: ( ( rule__Field__OppositeAssignment_4_1 ) )
            {
            // InternalSolverLanguageParser.g:8763:1: ( ( rule__Field__OppositeAssignment_4_1 ) )
            // InternalSolverLanguageParser.g:8764:2: ( rule__Field__OppositeAssignment_4_1 )
            {
             before(grammarAccess.getFieldAccess().getOppositeAssignment_4_1()); 
            // InternalSolverLanguageParser.g:8765:2: ( rule__Field__OppositeAssignment_4_1 )
            // InternalSolverLanguageParser.g:8765:3: rule__Field__OppositeAssignment_4_1
            {
            pushFollow(FOLLOW_2);
            rule__Field__OppositeAssignment_4_1();

            state._fsp--;


            }

             after(grammarAccess.getFieldAccess().getOppositeAssignment_4_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__Group_4__1__Impl"


    // $ANTLR start "rule__UnboundedMultiplicity__Group__0"
    // InternalSolverLanguageParser.g:8774:1: rule__UnboundedMultiplicity__Group__0 : rule__UnboundedMultiplicity__Group__0__Impl rule__UnboundedMultiplicity__Group__1 ;
    public final void rule__UnboundedMultiplicity__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8778:1: ( rule__UnboundedMultiplicity__Group__0__Impl rule__UnboundedMultiplicity__Group__1 )
            // InternalSolverLanguageParser.g:8779:2: rule__UnboundedMultiplicity__Group__0__Impl rule__UnboundedMultiplicity__Group__1
            {
            pushFollow(FOLLOW_62);
            rule__UnboundedMultiplicity__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnboundedMultiplicity__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnboundedMultiplicity__Group__0"


    // $ANTLR start "rule__UnboundedMultiplicity__Group__0__Impl"
    // InternalSolverLanguageParser.g:8786:1: rule__UnboundedMultiplicity__Group__0__Impl : ( () ) ;
    public final void rule__UnboundedMultiplicity__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8790:1: ( ( () ) )
            // InternalSolverLanguageParser.g:8791:1: ( () )
            {
            // InternalSolverLanguageParser.g:8791:1: ( () )
            // InternalSolverLanguageParser.g:8792:2: ()
            {
             before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0()); 
            // InternalSolverLanguageParser.g:8793:2: ()
            // InternalSolverLanguageParser.g:8793:3: 
            {
            }

             after(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0()); 

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnboundedMultiplicity__Group__0__Impl"


    // $ANTLR start "rule__UnboundedMultiplicity__Group__1"
    // InternalSolverLanguageParser.g:8801:1: rule__UnboundedMultiplicity__Group__1 : rule__UnboundedMultiplicity__Group__1__Impl rule__UnboundedMultiplicity__Group__2 ;
    public final void rule__UnboundedMultiplicity__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8805:1: ( rule__UnboundedMultiplicity__Group__1__Impl rule__UnboundedMultiplicity__Group__2 )
            // InternalSolverLanguageParser.g:8806:2: rule__UnboundedMultiplicity__Group__1__Impl rule__UnboundedMultiplicity__Group__2
            {
            pushFollow(FOLLOW_52);
            rule__UnboundedMultiplicity__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__UnboundedMultiplicity__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnboundedMultiplicity__Group__1"


    // $ANTLR start "rule__UnboundedMultiplicity__Group__1__Impl"
    // InternalSolverLanguageParser.g:8813:1: rule__UnboundedMultiplicity__Group__1__Impl : ( LeftSquareBracket ) ;
    public final void rule__UnboundedMultiplicity__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8817:1: ( ( LeftSquareBracket ) )
            // InternalSolverLanguageParser.g:8818:1: ( LeftSquareBracket )
            {
            // InternalSolverLanguageParser.g:8818:1: ( LeftSquareBracket )
            // InternalSolverLanguageParser.g:8819:2: LeftSquareBracket
            {
             before(grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); 
            match(input,LeftSquareBracket,FOLLOW_2); 
             after(grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnboundedMultiplicity__Group__1__Impl"


    // $ANTLR start "rule__UnboundedMultiplicity__Group__2"
    // InternalSolverLanguageParser.g:8828:1: rule__UnboundedMultiplicity__Group__2 : rule__UnboundedMultiplicity__Group__2__Impl ;
    public final void rule__UnboundedMultiplicity__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8832:1: ( rule__UnboundedMultiplicity__Group__2__Impl )
            // InternalSolverLanguageParser.g:8833:2: rule__UnboundedMultiplicity__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__UnboundedMultiplicity__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnboundedMultiplicity__Group__2"


    // $ANTLR start "rule__UnboundedMultiplicity__Group__2__Impl"
    // InternalSolverLanguageParser.g:8839:1: rule__UnboundedMultiplicity__Group__2__Impl : ( RightSquareBracket ) ;
    public final void rule__UnboundedMultiplicity__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8843:1: ( ( RightSquareBracket ) )
            // InternalSolverLanguageParser.g:8844:1: ( RightSquareBracket )
            {
            // InternalSolverLanguageParser.g:8844:1: ( RightSquareBracket )
            // InternalSolverLanguageParser.g:8845:2: RightSquareBracket
            {
             before(grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); 
            match(input,RightSquareBracket,FOLLOW_2); 
             after(grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnboundedMultiplicity__Group__2__Impl"


    // $ANTLR start "rule__ExactMultiplicity__Group__0"
    // InternalSolverLanguageParser.g:8855:1: rule__ExactMultiplicity__Group__0 : rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 ;
    public final void rule__ExactMultiplicity__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8859:1: ( rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 )
            // InternalSolverLanguageParser.g:8860:2: rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1
            {
            pushFollow(FOLLOW_63);
            rule__ExactMultiplicity__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExactMultiplicity__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__Group__0"


    // $ANTLR start "rule__ExactMultiplicity__Group__0__Impl"
    // InternalSolverLanguageParser.g:8867:1: rule__ExactMultiplicity__Group__0__Impl : ( LeftSquareBracket ) ;
    public final void rule__ExactMultiplicity__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8871:1: ( ( LeftSquareBracket ) )
            // InternalSolverLanguageParser.g:8872:1: ( LeftSquareBracket )
            {
            // InternalSolverLanguageParser.g:8872:1: ( LeftSquareBracket )
            // InternalSolverLanguageParser.g:8873:2: LeftSquareBracket
            {
             before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); 
            match(input,LeftSquareBracket,FOLLOW_2); 
             after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__Group__0__Impl"


    // $ANTLR start "rule__ExactMultiplicity__Group__1"
    // InternalSolverLanguageParser.g:8882:1: rule__ExactMultiplicity__Group__1 : rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 ;
    public final void rule__ExactMultiplicity__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8886:1: ( rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 )
            // InternalSolverLanguageParser.g:8887:2: rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2
            {
            pushFollow(FOLLOW_52);
            rule__ExactMultiplicity__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExactMultiplicity__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__Group__1"


    // $ANTLR start "rule__ExactMultiplicity__Group__1__Impl"
    // InternalSolverLanguageParser.g:8894:1: rule__ExactMultiplicity__Group__1__Impl : ( ( rule__ExactMultiplicity__ValueAssignment_1 ) ) ;
    public final void rule__ExactMultiplicity__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8898:1: ( ( ( rule__ExactMultiplicity__ValueAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:8899:1: ( ( rule__ExactMultiplicity__ValueAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:8899:1: ( ( rule__ExactMultiplicity__ValueAssignment_1 ) )
            // InternalSolverLanguageParser.g:8900:2: ( rule__ExactMultiplicity__ValueAssignment_1 )
            {
             before(grammarAccess.getExactMultiplicityAccess().getValueAssignment_1()); 
            // InternalSolverLanguageParser.g:8901:2: ( rule__ExactMultiplicity__ValueAssignment_1 )
            // InternalSolverLanguageParser.g:8901:3: rule__ExactMultiplicity__ValueAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ExactMultiplicity__ValueAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getExactMultiplicityAccess().getValueAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__Group__1__Impl"


    // $ANTLR start "rule__ExactMultiplicity__Group__2"
    // InternalSolverLanguageParser.g:8909:1: rule__ExactMultiplicity__Group__2 : rule__ExactMultiplicity__Group__2__Impl ;
    public final void rule__ExactMultiplicity__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8913:1: ( rule__ExactMultiplicity__Group__2__Impl )
            // InternalSolverLanguageParser.g:8914:2: rule__ExactMultiplicity__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExactMultiplicity__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__Group__2"


    // $ANTLR start "rule__ExactMultiplicity__Group__2__Impl"
    // InternalSolverLanguageParser.g:8920:1: rule__ExactMultiplicity__Group__2__Impl : ( RightSquareBracket ) ;
    public final void rule__ExactMultiplicity__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8924:1: ( ( RightSquareBracket ) )
            // InternalSolverLanguageParser.g:8925:1: ( RightSquareBracket )
            {
            // InternalSolverLanguageParser.g:8925:1: ( RightSquareBracket )
            // InternalSolverLanguageParser.g:8926:2: RightSquareBracket
            {
             before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); 
            match(input,RightSquareBracket,FOLLOW_2); 
             after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__Group__2__Impl"


    // $ANTLR start "rule__BoundedMultiplicity__Group__0"
    // InternalSolverLanguageParser.g:8936:1: rule__BoundedMultiplicity__Group__0 : rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 ;
    public final void rule__BoundedMultiplicity__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8940:1: ( rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 )
            // InternalSolverLanguageParser.g:8941:2: rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1
            {
            pushFollow(FOLLOW_64);
            rule__BoundedMultiplicity__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__0"


    // $ANTLR start "rule__BoundedMultiplicity__Group__0__Impl"
    // InternalSolverLanguageParser.g:8948:1: rule__BoundedMultiplicity__Group__0__Impl : ( LeftSquareBracket ) ;
    public final void rule__BoundedMultiplicity__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8952:1: ( ( LeftSquareBracket ) )
            // InternalSolverLanguageParser.g:8953:1: ( LeftSquareBracket )
            {
            // InternalSolverLanguageParser.g:8953:1: ( LeftSquareBracket )
            // InternalSolverLanguageParser.g:8954:2: LeftSquareBracket
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); 
            match(input,LeftSquareBracket,FOLLOW_2); 
             after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__0__Impl"


    // $ANTLR start "rule__BoundedMultiplicity__Group__1"
    // InternalSolverLanguageParser.g:8963:1: rule__BoundedMultiplicity__Group__1 : rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 ;
    public final void rule__BoundedMultiplicity__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8967:1: ( rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 )
            // InternalSolverLanguageParser.g:8968:2: rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2
            {
            pushFollow(FOLLOW_35);
            rule__BoundedMultiplicity__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__1"


    // $ANTLR start "rule__BoundedMultiplicity__Group__1__Impl"
    // InternalSolverLanguageParser.g:8975:1: rule__BoundedMultiplicity__Group__1__Impl : ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) ;
    public final void rule__BoundedMultiplicity__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8979:1: ( ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:8980:1: ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:8980:1: ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) )
            // InternalSolverLanguageParser.g:8981:2: ( rule__BoundedMultiplicity__LowerBoundAssignment_1 )
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); 
            // InternalSolverLanguageParser.g:8982:2: ( rule__BoundedMultiplicity__LowerBoundAssignment_1 )
            // InternalSolverLanguageParser.g:8982:3: rule__BoundedMultiplicity__LowerBoundAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__LowerBoundAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__1__Impl"


    // $ANTLR start "rule__BoundedMultiplicity__Group__2"
    // InternalSolverLanguageParser.g:8990:1: rule__BoundedMultiplicity__Group__2 : rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 ;
    public final void rule__BoundedMultiplicity__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:8994:1: ( rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 )
            // InternalSolverLanguageParser.g:8995:2: rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3
            {
            pushFollow(FOLLOW_63);
            rule__BoundedMultiplicity__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__2"


    // $ANTLR start "rule__BoundedMultiplicity__Group__2__Impl"
    // InternalSolverLanguageParser.g:9002:1: rule__BoundedMultiplicity__Group__2__Impl : ( Comma ) ;
    public final void rule__BoundedMultiplicity__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9006:1: ( ( Comma ) )
            // InternalSolverLanguageParser.g:9007:1: ( Comma )
            {
            // InternalSolverLanguageParser.g:9007:1: ( Comma )
            // InternalSolverLanguageParser.g:9008:2: Comma
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); 
            match(input,Comma,FOLLOW_2); 
             after(grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__2__Impl"


    // $ANTLR start "rule__BoundedMultiplicity__Group__3"
    // InternalSolverLanguageParser.g:9017:1: rule__BoundedMultiplicity__Group__3 : rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 ;
    public final void rule__BoundedMultiplicity__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9021:1: ( rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 )
            // InternalSolverLanguageParser.g:9022:2: rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4
            {
            pushFollow(FOLLOW_52);
            rule__BoundedMultiplicity__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__Group__4();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__3"


    // $ANTLR start "rule__BoundedMultiplicity__Group__3__Impl"
    // InternalSolverLanguageParser.g:9029:1: rule__BoundedMultiplicity__Group__3__Impl : ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) ;
    public final void rule__BoundedMultiplicity__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9033:1: ( ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:9034:1: ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:9034:1: ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) )
            // InternalSolverLanguageParser.g:9035:2: ( rule__BoundedMultiplicity__UpperBoundAssignment_3 )
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); 
            // InternalSolverLanguageParser.g:9036:2: ( rule__BoundedMultiplicity__UpperBoundAssignment_3 )
            // InternalSolverLanguageParser.g:9036:3: rule__BoundedMultiplicity__UpperBoundAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__UpperBoundAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__3__Impl"


    // $ANTLR start "rule__BoundedMultiplicity__Group__4"
    // InternalSolverLanguageParser.g:9044:1: rule__BoundedMultiplicity__Group__4 : rule__BoundedMultiplicity__Group__4__Impl ;
    public final void rule__BoundedMultiplicity__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9048:1: ( rule__BoundedMultiplicity__Group__4__Impl )
            // InternalSolverLanguageParser.g:9049:2: rule__BoundedMultiplicity__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BoundedMultiplicity__Group__4__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__4"


    // $ANTLR start "rule__BoundedMultiplicity__Group__4__Impl"
    // InternalSolverLanguageParser.g:9055:1: rule__BoundedMultiplicity__Group__4__Impl : ( RightSquareBracket ) ;
    public final void rule__BoundedMultiplicity__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9059:1: ( ( RightSquareBracket ) )
            // InternalSolverLanguageParser.g:9060:1: ( RightSquareBracket )
            {
            // InternalSolverLanguageParser.g:9060:1: ( RightSquareBracket )
            // InternalSolverLanguageParser.g:9061:2: RightSquareBracket
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); 
            match(input,RightSquareBracket,FOLLOW_2); 
             after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__Group__4__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group__0"
    // InternalSolverLanguageParser.g:9071:1: rule__EnumDeclaration__Group__0 : rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ;
    public final void rule__EnumDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9075:1: ( rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:9076:2: rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1
            {
            pushFollow(FOLLOW_48);
            rule__EnumDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group__0"


    // $ANTLR start "rule__EnumDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:9083:1: rule__EnumDeclaration__Group__0__Impl : ( Enum ) ;
    public final void rule__EnumDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9087:1: ( ( Enum ) )
            // InternalSolverLanguageParser.g:9088:1: ( Enum )
            {
            // InternalSolverLanguageParser.g:9088:1: ( Enum )
            // InternalSolverLanguageParser.g:9089:2: Enum
            {
             before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); 
            match(input,Enum,FOLLOW_2); 
             after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group__0__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group__1"
    // InternalSolverLanguageParser.g:9098:1: rule__EnumDeclaration__Group__1 : rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ;
    public final void rule__EnumDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9102:1: ( rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:9103:2: rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2
            {
            pushFollow(FOLLOW_65);
            rule__EnumDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group__1"


    // $ANTLR start "rule__EnumDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:9110:1: rule__EnumDeclaration__Group__1__Impl : ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ;
    public final void rule__EnumDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9114:1: ( ( ( rule__EnumDeclaration__NameAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:9115:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:9115:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) )
            // InternalSolverLanguageParser.g:9116:2: ( rule__EnumDeclaration__NameAssignment_1 )
            {
             before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); 
            // InternalSolverLanguageParser.g:9117:2: ( rule__EnumDeclaration__NameAssignment_1 )
            // InternalSolverLanguageParser.g:9117:3: rule__EnumDeclaration__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__NameAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group__1__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group__2"
    // InternalSolverLanguageParser.g:9125:1: rule__EnumDeclaration__Group__2 : rule__EnumDeclaration__Group__2__Impl ;
    public final void rule__EnumDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9129:1: ( rule__EnumDeclaration__Group__2__Impl )
            // InternalSolverLanguageParser.g:9130:2: rule__EnumDeclaration__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group__2"


    // $ANTLR start "rule__EnumDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:9136:1: rule__EnumDeclaration__Group__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2 ) ) ;
    public final void rule__EnumDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9140:1: ( ( ( rule__EnumDeclaration__Alternatives_2 ) ) )
            // InternalSolverLanguageParser.g:9141:1: ( ( rule__EnumDeclaration__Alternatives_2 ) )
            {
            // InternalSolverLanguageParser.g:9141:1: ( ( rule__EnumDeclaration__Alternatives_2 ) )
            // InternalSolverLanguageParser.g:9142:2: ( rule__EnumDeclaration__Alternatives_2 )
            {
             before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); 
            // InternalSolverLanguageParser.g:9143:2: ( rule__EnumDeclaration__Alternatives_2 )
            // InternalSolverLanguageParser.g:9143:3: rule__EnumDeclaration__Alternatives_2
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Alternatives_2();

            state._fsp--;


            }

             after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group__2__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0__0"
    // InternalSolverLanguageParser.g:9152:1: rule__EnumDeclaration__Group_2_0__0 : rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ;
    public final void rule__EnumDeclaration__Group_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9156:1: ( rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 )
            // InternalSolverLanguageParser.g:9157:2: rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1
            {
            pushFollow(FOLLOW_66);
            rule__EnumDeclaration__Group_2_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0__0"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0__0__Impl"
    // InternalSolverLanguageParser.g:9164:1: rule__EnumDeclaration__Group_2_0__0__Impl : ( LeftCurlyBracket ) ;
    public final void rule__EnumDeclaration__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9168:1: ( ( LeftCurlyBracket ) )
            // InternalSolverLanguageParser.g:9169:1: ( LeftCurlyBracket )
            {
            // InternalSolverLanguageParser.g:9169:1: ( LeftCurlyBracket )
            // InternalSolverLanguageParser.g:9170:2: LeftCurlyBracket
            {
             before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); 
            match(input,LeftCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0__0__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0__1"
    // InternalSolverLanguageParser.g:9179:1: rule__EnumDeclaration__Group_2_0__1 : rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ;
    public final void rule__EnumDeclaration__Group_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9183:1: ( rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 )
            // InternalSolverLanguageParser.g:9184:2: rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2
            {
            pushFollow(FOLLOW_66);
            rule__EnumDeclaration__Group_2_0__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0__1"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0__1__Impl"
    // InternalSolverLanguageParser.g:9191:1: rule__EnumDeclaration__Group_2_0__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ;
    public final void rule__EnumDeclaration__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9195:1: ( ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) )
            // InternalSolverLanguageParser.g:9196:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? )
            {
            // InternalSolverLanguageParser.g:9196:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? )
            // InternalSolverLanguageParser.g:9197:2: ( rule__EnumDeclaration__Group_2_0_1__0 )?
            {
             before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); 
            // InternalSolverLanguageParser.g:9198:2: ( rule__EnumDeclaration__Group_2_0_1__0 )?
            int alt63=2;
            int LA63_0 = input.LA(1);

            if ( (LA63_0==RULE_ID) ) {
                alt63=1;
            }
            switch (alt63) {
                case 1 :
                    // InternalSolverLanguageParser.g:9198:3: rule__EnumDeclaration__Group_2_0_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__EnumDeclaration__Group_2_0_1__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0__1__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0__2"
    // InternalSolverLanguageParser.g:9206:1: rule__EnumDeclaration__Group_2_0__2 : rule__EnumDeclaration__Group_2_0__2__Impl ;
    public final void rule__EnumDeclaration__Group_2_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9210:1: ( rule__EnumDeclaration__Group_2_0__2__Impl )
            // InternalSolverLanguageParser.g:9211:2: rule__EnumDeclaration__Group_2_0__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0__2"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0__2__Impl"
    // InternalSolverLanguageParser.g:9217:1: rule__EnumDeclaration__Group_2_0__2__Impl : ( RightCurlyBracket ) ;
    public final void rule__EnumDeclaration__Group_2_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9221:1: ( ( RightCurlyBracket ) )
            // InternalSolverLanguageParser.g:9222:1: ( RightCurlyBracket )
            {
            // InternalSolverLanguageParser.g:9222:1: ( RightCurlyBracket )
            // InternalSolverLanguageParser.g:9223:2: RightCurlyBracket
            {
             before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); 
            match(input,RightCurlyBracket,FOLLOW_2); 
             after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0__2__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0"
    // InternalSolverLanguageParser.g:9233:1: rule__EnumDeclaration__Group_2_0_1__0 : rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ;
    public final void rule__EnumDeclaration__Group_2_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9237:1: ( rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 )
            // InternalSolverLanguageParser.g:9238:2: rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1
            {
            pushFollow(FOLLOW_67);
            rule__EnumDeclaration__Group_2_0_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__0"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0__Impl"
    // InternalSolverLanguageParser.g:9245:1: rule__EnumDeclaration__Group_2_0_1__0__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ;
    public final void rule__EnumDeclaration__Group_2_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9249:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) )
            // InternalSolverLanguageParser.g:9250:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) )
            {
            // InternalSolverLanguageParser.g:9250:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) )
            // InternalSolverLanguageParser.g:9251:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 )
            {
             before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); 
            // InternalSolverLanguageParser.g:9252:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 )
            // InternalSolverLanguageParser.g:9252:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__LiteralsAssignment_2_0_1_0();

            state._fsp--;


            }

             after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__0__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1"
    // InternalSolverLanguageParser.g:9260:1: rule__EnumDeclaration__Group_2_0_1__1 : rule__EnumDeclaration__Group_2_0_1__1__Impl ;
    public final void rule__EnumDeclaration__Group_2_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9264:1: ( rule__EnumDeclaration__Group_2_0_1__1__Impl )
            // InternalSolverLanguageParser.g:9265:2: rule__EnumDeclaration__Group_2_0_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0_1__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__1"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1__Impl"
    // InternalSolverLanguageParser.g:9271:1: rule__EnumDeclaration__Group_2_0_1__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ;
    public final void rule__EnumDeclaration__Group_2_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9275:1: ( ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) )
            // InternalSolverLanguageParser.g:9276:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* )
            {
            // InternalSolverLanguageParser.g:9276:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* )
            // InternalSolverLanguageParser.g:9277:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )*
            {
             before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); 
            // InternalSolverLanguageParser.g:9278:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )*
            loop64:
            do {
                int alt64=2;
                int LA64_0 = input.LA(1);

                if ( (LA64_0==Comma||LA64_0==RULE_ID) ) {
                    alt64=1;
                }


                switch (alt64) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:9278:3: rule__EnumDeclaration__Group_2_0_1_1__0
            	    {
            	    pushFollow(FOLLOW_68);
            	    rule__EnumDeclaration__Group_2_0_1_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop64;
                }
            } while (true);

             after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__1__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0"
    // InternalSolverLanguageParser.g:9287:1: rule__EnumDeclaration__Group_2_0_1_1__0 : rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ;
    public final void rule__EnumDeclaration__Group_2_0_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9291:1: ( rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 )
            // InternalSolverLanguageParser.g:9292:2: rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1
            {
            pushFollow(FOLLOW_67);
            rule__EnumDeclaration__Group_2_0_1_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0_1_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__0"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0__Impl"
    // InternalSolverLanguageParser.g:9299:1: rule__EnumDeclaration__Group_2_0_1_1__0__Impl : ( ( Comma )? ) ;
    public final void rule__EnumDeclaration__Group_2_0_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9303:1: ( ( ( Comma )? ) )
            // InternalSolverLanguageParser.g:9304:1: ( ( Comma )? )
            {
            // InternalSolverLanguageParser.g:9304:1: ( ( Comma )? )
            // InternalSolverLanguageParser.g:9305:2: ( Comma )?
            {
             before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); 
            // InternalSolverLanguageParser.g:9306:2: ( Comma )?
            int alt65=2;
            int LA65_0 = input.LA(1);

            if ( (LA65_0==Comma) ) {
                alt65=1;
            }
            switch (alt65) {
                case 1 :
                    // InternalSolverLanguageParser.g:9306:3: Comma
                    {
                    match(input,Comma,FOLLOW_2); 

                    }
                    break;

            }

             after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__0__Impl"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1"
    // InternalSolverLanguageParser.g:9314:1: rule__EnumDeclaration__Group_2_0_1_1__1 : rule__EnumDeclaration__Group_2_0_1_1__1__Impl ;
    public final void rule__EnumDeclaration__Group_2_0_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9318:1: ( rule__EnumDeclaration__Group_2_0_1_1__1__Impl )
            // InternalSolverLanguageParser.g:9319:2: rule__EnumDeclaration__Group_2_0_1_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__Group_2_0_1_1__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__1"


    // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1__Impl"
    // InternalSolverLanguageParser.g:9325:1: rule__EnumDeclaration__Group_2_0_1_1__1__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ;
    public final void rule__EnumDeclaration__Group_2_0_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9329:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) )
            // InternalSolverLanguageParser.g:9330:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) )
            {
            // InternalSolverLanguageParser.g:9330:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) )
            // InternalSolverLanguageParser.g:9331:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 )
            {
             before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); 
            // InternalSolverLanguageParser.g:9332:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 )
            // InternalSolverLanguageParser.g:9332:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1
            {
            pushFollow(FOLLOW_2);
            rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1();

            state._fsp--;


            }

             after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__1__Impl"


    // $ANTLR start "rule__ExactScope__Group__0"
    // InternalSolverLanguageParser.g:9341:1: rule__ExactScope__Group__0 : rule__ExactScope__Group__0__Impl rule__ExactScope__Group__1 ;
    public final void rule__ExactScope__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9345:1: ( rule__ExactScope__Group__0__Impl rule__ExactScope__Group__1 )
            // InternalSolverLanguageParser.g:9346:2: rule__ExactScope__Group__0__Impl rule__ExactScope__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__ExactScope__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExactScope__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__0"


    // $ANTLR start "rule__ExactScope__Group__0__Impl"
    // InternalSolverLanguageParser.g:9353:1: rule__ExactScope__Group__0__Impl : ( Scope ) ;
    public final void rule__ExactScope__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9357:1: ( ( Scope ) )
            // InternalSolverLanguageParser.g:9358:1: ( Scope )
            {
            // InternalSolverLanguageParser.g:9358:1: ( Scope )
            // InternalSolverLanguageParser.g:9359:2: Scope
            {
             before(grammarAccess.getExactScopeAccess().getScopeKeyword_0()); 
            match(input,Scope,FOLLOW_2); 
             after(grammarAccess.getExactScopeAccess().getScopeKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__0__Impl"


    // $ANTLR start "rule__ExactScope__Group__1"
    // InternalSolverLanguageParser.g:9368:1: rule__ExactScope__Group__1 : rule__ExactScope__Group__1__Impl rule__ExactScope__Group__2 ;
    public final void rule__ExactScope__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9372:1: ( rule__ExactScope__Group__1__Impl rule__ExactScope__Group__2 )
            // InternalSolverLanguageParser.g:9373:2: rule__ExactScope__Group__1__Impl rule__ExactScope__Group__2
            {
            pushFollow(FOLLOW_69);
            rule__ExactScope__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExactScope__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__1"


    // $ANTLR start "rule__ExactScope__Group__1__Impl"
    // InternalSolverLanguageParser.g:9380:1: rule__ExactScope__Group__1__Impl : ( ( rule__ExactScope__TypeAssignment_1 ) ) ;
    public final void rule__ExactScope__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9384:1: ( ( ( rule__ExactScope__TypeAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:9385:1: ( ( rule__ExactScope__TypeAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:9385:1: ( ( rule__ExactScope__TypeAssignment_1 ) )
            // InternalSolverLanguageParser.g:9386:2: ( rule__ExactScope__TypeAssignment_1 )
            {
             before(grammarAccess.getExactScopeAccess().getTypeAssignment_1()); 
            // InternalSolverLanguageParser.g:9387:2: ( rule__ExactScope__TypeAssignment_1 )
            // InternalSolverLanguageParser.g:9387:3: rule__ExactScope__TypeAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ExactScope__TypeAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getExactScopeAccess().getTypeAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__1__Impl"


    // $ANTLR start "rule__ExactScope__Group__2"
    // InternalSolverLanguageParser.g:9395:1: rule__ExactScope__Group__2 : rule__ExactScope__Group__2__Impl rule__ExactScope__Group__3 ;
    public final void rule__ExactScope__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9399:1: ( rule__ExactScope__Group__2__Impl rule__ExactScope__Group__3 )
            // InternalSolverLanguageParser.g:9400:2: rule__ExactScope__Group__2__Impl rule__ExactScope__Group__3
            {
            pushFollow(FOLLOW_64);
            rule__ExactScope__Group__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExactScope__Group__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__2"


    // $ANTLR start "rule__ExactScope__Group__2__Impl"
    // InternalSolverLanguageParser.g:9407:1: rule__ExactScope__Group__2__Impl : ( EqualsSignEqualsSign ) ;
    public final void rule__ExactScope__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9411:1: ( ( EqualsSignEqualsSign ) )
            // InternalSolverLanguageParser.g:9412:1: ( EqualsSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:9412:1: ( EqualsSignEqualsSign )
            // InternalSolverLanguageParser.g:9413:2: EqualsSignEqualsSign
            {
             before(grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); 
            match(input,EqualsSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__2__Impl"


    // $ANTLR start "rule__ExactScope__Group__3"
    // InternalSolverLanguageParser.g:9422:1: rule__ExactScope__Group__3 : rule__ExactScope__Group__3__Impl rule__ExactScope__Group__4 ;
    public final void rule__ExactScope__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9426:1: ( rule__ExactScope__Group__3__Impl rule__ExactScope__Group__4 )
            // InternalSolverLanguageParser.g:9427:2: rule__ExactScope__Group__3__Impl rule__ExactScope__Group__4
            {
            pushFollow(FOLLOW_7);
            rule__ExactScope__Group__3__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ExactScope__Group__4();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__3"


    // $ANTLR start "rule__ExactScope__Group__3__Impl"
    // InternalSolverLanguageParser.g:9434:1: rule__ExactScope__Group__3__Impl : ( ( rule__ExactScope__SizeAssignment_3 ) ) ;
    public final void rule__ExactScope__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9438:1: ( ( ( rule__ExactScope__SizeAssignment_3 ) ) )
            // InternalSolverLanguageParser.g:9439:1: ( ( rule__ExactScope__SizeAssignment_3 ) )
            {
            // InternalSolverLanguageParser.g:9439:1: ( ( rule__ExactScope__SizeAssignment_3 ) )
            // InternalSolverLanguageParser.g:9440:2: ( rule__ExactScope__SizeAssignment_3 )
            {
             before(grammarAccess.getExactScopeAccess().getSizeAssignment_3()); 
            // InternalSolverLanguageParser.g:9441:2: ( rule__ExactScope__SizeAssignment_3 )
            // InternalSolverLanguageParser.g:9441:3: rule__ExactScope__SizeAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__ExactScope__SizeAssignment_3();

            state._fsp--;


            }

             after(grammarAccess.getExactScopeAccess().getSizeAssignment_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__3__Impl"


    // $ANTLR start "rule__ExactScope__Group__4"
    // InternalSolverLanguageParser.g:9449:1: rule__ExactScope__Group__4 : rule__ExactScope__Group__4__Impl ;
    public final void rule__ExactScope__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9453:1: ( rule__ExactScope__Group__4__Impl )
            // InternalSolverLanguageParser.g:9454:2: rule__ExactScope__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExactScope__Group__4__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__4"


    // $ANTLR start "rule__ExactScope__Group__4__Impl"
    // InternalSolverLanguageParser.g:9460:1: rule__ExactScope__Group__4__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__ExactScope__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9464:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:9465:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:9465:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:9466:2: RULE_FULL_STOP
            {
             before(grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__Group__4__Impl"


    // $ANTLR start "rule__BoundedScope__Group__0"
    // InternalSolverLanguageParser.g:9476:1: rule__BoundedScope__Group__0 : rule__BoundedScope__Group__0__Impl rule__BoundedScope__Group__1 ;
    public final void rule__BoundedScope__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9480:1: ( rule__BoundedScope__Group__0__Impl rule__BoundedScope__Group__1 )
            // InternalSolverLanguageParser.g:9481:2: rule__BoundedScope__Group__0__Impl rule__BoundedScope__Group__1
            {
            pushFollow(FOLLOW_70);
            rule__BoundedScope__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group__0"


    // $ANTLR start "rule__BoundedScope__Group__0__Impl"
    // InternalSolverLanguageParser.g:9488:1: rule__BoundedScope__Group__0__Impl : ( Scope ) ;
    public final void rule__BoundedScope__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9492:1: ( ( Scope ) )
            // InternalSolverLanguageParser.g:9493:1: ( Scope )
            {
            // InternalSolverLanguageParser.g:9493:1: ( Scope )
            // InternalSolverLanguageParser.g:9494:2: Scope
            {
             before(grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); 
            match(input,Scope,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group__0__Impl"


    // $ANTLR start "rule__BoundedScope__Group__1"
    // InternalSolverLanguageParser.g:9503:1: rule__BoundedScope__Group__1 : rule__BoundedScope__Group__1__Impl rule__BoundedScope__Group__2 ;
    public final void rule__BoundedScope__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9507:1: ( rule__BoundedScope__Group__1__Impl rule__BoundedScope__Group__2 )
            // InternalSolverLanguageParser.g:9508:2: rule__BoundedScope__Group__1__Impl rule__BoundedScope__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__BoundedScope__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group__1"


    // $ANTLR start "rule__BoundedScope__Group__1__Impl"
    // InternalSolverLanguageParser.g:9515:1: rule__BoundedScope__Group__1__Impl : ( ( rule__BoundedScope__Alternatives_1 ) ) ;
    public final void rule__BoundedScope__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9519:1: ( ( ( rule__BoundedScope__Alternatives_1 ) ) )
            // InternalSolverLanguageParser.g:9520:1: ( ( rule__BoundedScope__Alternatives_1 ) )
            {
            // InternalSolverLanguageParser.g:9520:1: ( ( rule__BoundedScope__Alternatives_1 ) )
            // InternalSolverLanguageParser.g:9521:2: ( rule__BoundedScope__Alternatives_1 )
            {
             before(grammarAccess.getBoundedScopeAccess().getAlternatives_1()); 
            // InternalSolverLanguageParser.g:9522:2: ( rule__BoundedScope__Alternatives_1 )
            // InternalSolverLanguageParser.g:9522:3: rule__BoundedScope__Alternatives_1
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Alternatives_1();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getAlternatives_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group__1__Impl"


    // $ANTLR start "rule__BoundedScope__Group__2"
    // InternalSolverLanguageParser.g:9530:1: rule__BoundedScope__Group__2 : rule__BoundedScope__Group__2__Impl ;
    public final void rule__BoundedScope__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9534:1: ( rule__BoundedScope__Group__2__Impl )
            // InternalSolverLanguageParser.g:9535:2: rule__BoundedScope__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group__2"


    // $ANTLR start "rule__BoundedScope__Group__2__Impl"
    // InternalSolverLanguageParser.g:9541:1: rule__BoundedScope__Group__2__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__BoundedScope__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9545:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:9546:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:9546:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:9547:2: RULE_FULL_STOP
            {
             before(grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group__2__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_0__0"
    // InternalSolverLanguageParser.g:9557:1: rule__BoundedScope__Group_1_0__0 : rule__BoundedScope__Group_1_0__0__Impl rule__BoundedScope__Group_1_0__1 ;
    public final void rule__BoundedScope__Group_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9561:1: ( rule__BoundedScope__Group_1_0__0__Impl rule__BoundedScope__Group_1_0__1 )
            // InternalSolverLanguageParser.g:9562:2: rule__BoundedScope__Group_1_0__0__Impl rule__BoundedScope__Group_1_0__1
            {
            pushFollow(FOLLOW_70);
            rule__BoundedScope__Group_1_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_0__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__0"


    // $ANTLR start "rule__BoundedScope__Group_1_0__0__Impl"
    // InternalSolverLanguageParser.g:9569:1: rule__BoundedScope__Group_1_0__0__Impl : ( ( rule__BoundedScope__Group_1_0_0__0 )? ) ;
    public final void rule__BoundedScope__Group_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9573:1: ( ( ( rule__BoundedScope__Group_1_0_0__0 )? ) )
            // InternalSolverLanguageParser.g:9574:1: ( ( rule__BoundedScope__Group_1_0_0__0 )? )
            {
            // InternalSolverLanguageParser.g:9574:1: ( ( rule__BoundedScope__Group_1_0_0__0 )? )
            // InternalSolverLanguageParser.g:9575:2: ( rule__BoundedScope__Group_1_0_0__0 )?
            {
             before(grammarAccess.getBoundedScopeAccess().getGroup_1_0_0()); 
            // InternalSolverLanguageParser.g:9576:2: ( rule__BoundedScope__Group_1_0_0__0 )?
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( (LA66_0==RULE_INT) ) {
                alt66=1;
            }
            switch (alt66) {
                case 1 :
                    // InternalSolverLanguageParser.g:9576:3: rule__BoundedScope__Group_1_0_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__BoundedScope__Group_1_0_0__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getBoundedScopeAccess().getGroup_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__0__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_0__1"
    // InternalSolverLanguageParser.g:9584:1: rule__BoundedScope__Group_1_0__1 : rule__BoundedScope__Group_1_0__1__Impl rule__BoundedScope__Group_1_0__2 ;
    public final void rule__BoundedScope__Group_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9588:1: ( rule__BoundedScope__Group_1_0__1__Impl rule__BoundedScope__Group_1_0__2 )
            // InternalSolverLanguageParser.g:9589:2: rule__BoundedScope__Group_1_0__1__Impl rule__BoundedScope__Group_1_0__2
            {
            pushFollow(FOLLOW_71);
            rule__BoundedScope__Group_1_0__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_0__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__1"


    // $ANTLR start "rule__BoundedScope__Group_1_0__1__Impl"
    // InternalSolverLanguageParser.g:9596:1: rule__BoundedScope__Group_1_0__1__Impl : ( ( rule__BoundedScope__TypeAssignment_1_0_1 ) ) ;
    public final void rule__BoundedScope__Group_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9600:1: ( ( ( rule__BoundedScope__TypeAssignment_1_0_1 ) ) )
            // InternalSolverLanguageParser.g:9601:1: ( ( rule__BoundedScope__TypeAssignment_1_0_1 ) )
            {
            // InternalSolverLanguageParser.g:9601:1: ( ( rule__BoundedScope__TypeAssignment_1_0_1 ) )
            // InternalSolverLanguageParser.g:9602:2: ( rule__BoundedScope__TypeAssignment_1_0_1 )
            {
             before(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_0_1()); 
            // InternalSolverLanguageParser.g:9603:2: ( rule__BoundedScope__TypeAssignment_1_0_1 )
            // InternalSolverLanguageParser.g:9603:3: rule__BoundedScope__TypeAssignment_1_0_1
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__TypeAssignment_1_0_1();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_0_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__1__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_0__2"
    // InternalSolverLanguageParser.g:9611:1: rule__BoundedScope__Group_1_0__2 : rule__BoundedScope__Group_1_0__2__Impl rule__BoundedScope__Group_1_0__3 ;
    public final void rule__BoundedScope__Group_1_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9615:1: ( rule__BoundedScope__Group_1_0__2__Impl rule__BoundedScope__Group_1_0__3 )
            // InternalSolverLanguageParser.g:9616:2: rule__BoundedScope__Group_1_0__2__Impl rule__BoundedScope__Group_1_0__3
            {
            pushFollow(FOLLOW_64);
            rule__BoundedScope__Group_1_0__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_0__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__2"


    // $ANTLR start "rule__BoundedScope__Group_1_0__2__Impl"
    // InternalSolverLanguageParser.g:9623:1: rule__BoundedScope__Group_1_0__2__Impl : ( LessThanSignEqualsSign ) ;
    public final void rule__BoundedScope__Group_1_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9627:1: ( ( LessThanSignEqualsSign ) )
            // InternalSolverLanguageParser.g:9628:1: ( LessThanSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:9628:1: ( LessThanSignEqualsSign )
            // InternalSolverLanguageParser.g:9629:2: LessThanSignEqualsSign
            {
             before(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); 
            match(input,LessThanSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__2__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_0__3"
    // InternalSolverLanguageParser.g:9638:1: rule__BoundedScope__Group_1_0__3 : rule__BoundedScope__Group_1_0__3__Impl ;
    public final void rule__BoundedScope__Group_1_0__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9642:1: ( rule__BoundedScope__Group_1_0__3__Impl )
            // InternalSolverLanguageParser.g:9643:2: rule__BoundedScope__Group_1_0__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_0__3__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__3"


    // $ANTLR start "rule__BoundedScope__Group_1_0__3__Impl"
    // InternalSolverLanguageParser.g:9649:1: rule__BoundedScope__Group_1_0__3__Impl : ( ( rule__BoundedScope__UpperBoundAssignment_1_0_3 ) ) ;
    public final void rule__BoundedScope__Group_1_0__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9653:1: ( ( ( rule__BoundedScope__UpperBoundAssignment_1_0_3 ) ) )
            // InternalSolverLanguageParser.g:9654:1: ( ( rule__BoundedScope__UpperBoundAssignment_1_0_3 ) )
            {
            // InternalSolverLanguageParser.g:9654:1: ( ( rule__BoundedScope__UpperBoundAssignment_1_0_3 ) )
            // InternalSolverLanguageParser.g:9655:2: ( rule__BoundedScope__UpperBoundAssignment_1_0_3 )
            {
             before(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_0_3()); 
            // InternalSolverLanguageParser.g:9656:2: ( rule__BoundedScope__UpperBoundAssignment_1_0_3 )
            // InternalSolverLanguageParser.g:9656:3: rule__BoundedScope__UpperBoundAssignment_1_0_3
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__UpperBoundAssignment_1_0_3();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_0_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0__3__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_0_0__0"
    // InternalSolverLanguageParser.g:9665:1: rule__BoundedScope__Group_1_0_0__0 : rule__BoundedScope__Group_1_0_0__0__Impl rule__BoundedScope__Group_1_0_0__1 ;
    public final void rule__BoundedScope__Group_1_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9669:1: ( rule__BoundedScope__Group_1_0_0__0__Impl rule__BoundedScope__Group_1_0_0__1 )
            // InternalSolverLanguageParser.g:9670:2: rule__BoundedScope__Group_1_0_0__0__Impl rule__BoundedScope__Group_1_0_0__1
            {
            pushFollow(FOLLOW_71);
            rule__BoundedScope__Group_1_0_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_0_0__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0_0__0"


    // $ANTLR start "rule__BoundedScope__Group_1_0_0__0__Impl"
    // InternalSolverLanguageParser.g:9677:1: rule__BoundedScope__Group_1_0_0__0__Impl : ( ( rule__BoundedScope__LowerBoundAssignment_1_0_0_0 ) ) ;
    public final void rule__BoundedScope__Group_1_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9681:1: ( ( ( rule__BoundedScope__LowerBoundAssignment_1_0_0_0 ) ) )
            // InternalSolverLanguageParser.g:9682:1: ( ( rule__BoundedScope__LowerBoundAssignment_1_0_0_0 ) )
            {
            // InternalSolverLanguageParser.g:9682:1: ( ( rule__BoundedScope__LowerBoundAssignment_1_0_0_0 ) )
            // InternalSolverLanguageParser.g:9683:2: ( rule__BoundedScope__LowerBoundAssignment_1_0_0_0 )
            {
             before(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_0_0_0()); 
            // InternalSolverLanguageParser.g:9684:2: ( rule__BoundedScope__LowerBoundAssignment_1_0_0_0 )
            // InternalSolverLanguageParser.g:9684:3: rule__BoundedScope__LowerBoundAssignment_1_0_0_0
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__LowerBoundAssignment_1_0_0_0();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_0_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0_0__0__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_0_0__1"
    // InternalSolverLanguageParser.g:9692:1: rule__BoundedScope__Group_1_0_0__1 : rule__BoundedScope__Group_1_0_0__1__Impl ;
    public final void rule__BoundedScope__Group_1_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9696:1: ( rule__BoundedScope__Group_1_0_0__1__Impl )
            // InternalSolverLanguageParser.g:9697:2: rule__BoundedScope__Group_1_0_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_0_0__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0_0__1"


    // $ANTLR start "rule__BoundedScope__Group_1_0_0__1__Impl"
    // InternalSolverLanguageParser.g:9703:1: rule__BoundedScope__Group_1_0_0__1__Impl : ( LessThanSignEqualsSign ) ;
    public final void rule__BoundedScope__Group_1_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9707:1: ( ( LessThanSignEqualsSign ) )
            // InternalSolverLanguageParser.g:9708:1: ( LessThanSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:9708:1: ( LessThanSignEqualsSign )
            // InternalSolverLanguageParser.g:9709:2: LessThanSignEqualsSign
            {
             before(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); 
            match(input,LessThanSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_0_0__1__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_1__0"
    // InternalSolverLanguageParser.g:9719:1: rule__BoundedScope__Group_1_1__0 : rule__BoundedScope__Group_1_1__0__Impl rule__BoundedScope__Group_1_1__1 ;
    public final void rule__BoundedScope__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9723:1: ( rule__BoundedScope__Group_1_1__0__Impl rule__BoundedScope__Group_1_1__1 )
            // InternalSolverLanguageParser.g:9724:2: rule__BoundedScope__Group_1_1__0__Impl rule__BoundedScope__Group_1_1__1
            {
            pushFollow(FOLLOW_72);
            rule__BoundedScope__Group_1_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__0"


    // $ANTLR start "rule__BoundedScope__Group_1_1__0__Impl"
    // InternalSolverLanguageParser.g:9731:1: rule__BoundedScope__Group_1_1__0__Impl : ( ( rule__BoundedScope__UpperBoundAssignment_1_1_0 ) ) ;
    public final void rule__BoundedScope__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9735:1: ( ( ( rule__BoundedScope__UpperBoundAssignment_1_1_0 ) ) )
            // InternalSolverLanguageParser.g:9736:1: ( ( rule__BoundedScope__UpperBoundAssignment_1_1_0 ) )
            {
            // InternalSolverLanguageParser.g:9736:1: ( ( rule__BoundedScope__UpperBoundAssignment_1_1_0 ) )
            // InternalSolverLanguageParser.g:9737:2: ( rule__BoundedScope__UpperBoundAssignment_1_1_0 )
            {
             before(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_1_0()); 
            // InternalSolverLanguageParser.g:9738:2: ( rule__BoundedScope__UpperBoundAssignment_1_1_0 )
            // InternalSolverLanguageParser.g:9738:3: rule__BoundedScope__UpperBoundAssignment_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__UpperBoundAssignment_1_1_0();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__0__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_1__1"
    // InternalSolverLanguageParser.g:9746:1: rule__BoundedScope__Group_1_1__1 : rule__BoundedScope__Group_1_1__1__Impl rule__BoundedScope__Group_1_1__2 ;
    public final void rule__BoundedScope__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9750:1: ( rule__BoundedScope__Group_1_1__1__Impl rule__BoundedScope__Group_1_1__2 )
            // InternalSolverLanguageParser.g:9751:2: rule__BoundedScope__Group_1_1__1__Impl rule__BoundedScope__Group_1_1__2
            {
            pushFollow(FOLLOW_6);
            rule__BoundedScope__Group_1_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__1"


    // $ANTLR start "rule__BoundedScope__Group_1_1__1__Impl"
    // InternalSolverLanguageParser.g:9758:1: rule__BoundedScope__Group_1_1__1__Impl : ( GreaterThanSignEqualsSign ) ;
    public final void rule__BoundedScope__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9762:1: ( ( GreaterThanSignEqualsSign ) )
            // InternalSolverLanguageParser.g:9763:1: ( GreaterThanSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:9763:1: ( GreaterThanSignEqualsSign )
            // InternalSolverLanguageParser.g:9764:2: GreaterThanSignEqualsSign
            {
             before(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); 
            match(input,GreaterThanSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__1__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_1__2"
    // InternalSolverLanguageParser.g:9773:1: rule__BoundedScope__Group_1_1__2 : rule__BoundedScope__Group_1_1__2__Impl rule__BoundedScope__Group_1_1__3 ;
    public final void rule__BoundedScope__Group_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9777:1: ( rule__BoundedScope__Group_1_1__2__Impl rule__BoundedScope__Group_1_1__3 )
            // InternalSolverLanguageParser.g:9778:2: rule__BoundedScope__Group_1_1__2__Impl rule__BoundedScope__Group_1_1__3
            {
            pushFollow(FOLLOW_72);
            rule__BoundedScope__Group_1_1__2__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_1__3();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__2"


    // $ANTLR start "rule__BoundedScope__Group_1_1__2__Impl"
    // InternalSolverLanguageParser.g:9785:1: rule__BoundedScope__Group_1_1__2__Impl : ( ( rule__BoundedScope__TypeAssignment_1_1_2 ) ) ;
    public final void rule__BoundedScope__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9789:1: ( ( ( rule__BoundedScope__TypeAssignment_1_1_2 ) ) )
            // InternalSolverLanguageParser.g:9790:1: ( ( rule__BoundedScope__TypeAssignment_1_1_2 ) )
            {
            // InternalSolverLanguageParser.g:9790:1: ( ( rule__BoundedScope__TypeAssignment_1_1_2 ) )
            // InternalSolverLanguageParser.g:9791:2: ( rule__BoundedScope__TypeAssignment_1_1_2 )
            {
             before(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_1_2()); 
            // InternalSolverLanguageParser.g:9792:2: ( rule__BoundedScope__TypeAssignment_1_1_2 )
            // InternalSolverLanguageParser.g:9792:3: rule__BoundedScope__TypeAssignment_1_1_2
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__TypeAssignment_1_1_2();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__2__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_1__3"
    // InternalSolverLanguageParser.g:9800:1: rule__BoundedScope__Group_1_1__3 : rule__BoundedScope__Group_1_1__3__Impl ;
    public final void rule__BoundedScope__Group_1_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9804:1: ( rule__BoundedScope__Group_1_1__3__Impl )
            // InternalSolverLanguageParser.g:9805:2: rule__BoundedScope__Group_1_1__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_1__3__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__3"


    // $ANTLR start "rule__BoundedScope__Group_1_1__3__Impl"
    // InternalSolverLanguageParser.g:9811:1: rule__BoundedScope__Group_1_1__3__Impl : ( ( rule__BoundedScope__Group_1_1_3__0 )? ) ;
    public final void rule__BoundedScope__Group_1_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9815:1: ( ( ( rule__BoundedScope__Group_1_1_3__0 )? ) )
            // InternalSolverLanguageParser.g:9816:1: ( ( rule__BoundedScope__Group_1_1_3__0 )? )
            {
            // InternalSolverLanguageParser.g:9816:1: ( ( rule__BoundedScope__Group_1_1_3__0 )? )
            // InternalSolverLanguageParser.g:9817:2: ( rule__BoundedScope__Group_1_1_3__0 )?
            {
             before(grammarAccess.getBoundedScopeAccess().getGroup_1_1_3()); 
            // InternalSolverLanguageParser.g:9818:2: ( rule__BoundedScope__Group_1_1_3__0 )?
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==GreaterThanSignEqualsSign) ) {
                alt67=1;
            }
            switch (alt67) {
                case 1 :
                    // InternalSolverLanguageParser.g:9818:3: rule__BoundedScope__Group_1_1_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__BoundedScope__Group_1_1_3__0();

                    state._fsp--;


                    }
                    break;

            }

             after(grammarAccess.getBoundedScopeAccess().getGroup_1_1_3()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1__3__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_1_3__0"
    // InternalSolverLanguageParser.g:9827:1: rule__BoundedScope__Group_1_1_3__0 : rule__BoundedScope__Group_1_1_3__0__Impl rule__BoundedScope__Group_1_1_3__1 ;
    public final void rule__BoundedScope__Group_1_1_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9831:1: ( rule__BoundedScope__Group_1_1_3__0__Impl rule__BoundedScope__Group_1_1_3__1 )
            // InternalSolverLanguageParser.g:9832:2: rule__BoundedScope__Group_1_1_3__0__Impl rule__BoundedScope__Group_1_1_3__1
            {
            pushFollow(FOLLOW_64);
            rule__BoundedScope__Group_1_1_3__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_1_3__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1_3__0"


    // $ANTLR start "rule__BoundedScope__Group_1_1_3__0__Impl"
    // InternalSolverLanguageParser.g:9839:1: rule__BoundedScope__Group_1_1_3__0__Impl : ( GreaterThanSignEqualsSign ) ;
    public final void rule__BoundedScope__Group_1_1_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9843:1: ( ( GreaterThanSignEqualsSign ) )
            // InternalSolverLanguageParser.g:9844:1: ( GreaterThanSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:9844:1: ( GreaterThanSignEqualsSign )
            // InternalSolverLanguageParser.g:9845:2: GreaterThanSignEqualsSign
            {
             before(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); 
            match(input,GreaterThanSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1_3__0__Impl"


    // $ANTLR start "rule__BoundedScope__Group_1_1_3__1"
    // InternalSolverLanguageParser.g:9854:1: rule__BoundedScope__Group_1_1_3__1 : rule__BoundedScope__Group_1_1_3__1__Impl ;
    public final void rule__BoundedScope__Group_1_1_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9858:1: ( rule__BoundedScope__Group_1_1_3__1__Impl )
            // InternalSolverLanguageParser.g:9859:2: rule__BoundedScope__Group_1_1_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__Group_1_1_3__1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1_3__1"


    // $ANTLR start "rule__BoundedScope__Group_1_1_3__1__Impl"
    // InternalSolverLanguageParser.g:9865:1: rule__BoundedScope__Group_1_1_3__1__Impl : ( ( rule__BoundedScope__LowerBoundAssignment_1_1_3_1 ) ) ;
    public final void rule__BoundedScope__Group_1_1_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9869:1: ( ( ( rule__BoundedScope__LowerBoundAssignment_1_1_3_1 ) ) )
            // InternalSolverLanguageParser.g:9870:1: ( ( rule__BoundedScope__LowerBoundAssignment_1_1_3_1 ) )
            {
            // InternalSolverLanguageParser.g:9870:1: ( ( rule__BoundedScope__LowerBoundAssignment_1_1_3_1 ) )
            // InternalSolverLanguageParser.g:9871:2: ( rule__BoundedScope__LowerBoundAssignment_1_1_3_1 )
            {
             before(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_1_3_1()); 
            // InternalSolverLanguageParser.g:9872:2: ( rule__BoundedScope__LowerBoundAssignment_1_1_3_1 )
            // InternalSolverLanguageParser.g:9872:3: rule__BoundedScope__LowerBoundAssignment_1_1_3_1
            {
            pushFollow(FOLLOW_2);
            rule__BoundedScope__LowerBoundAssignment_1_1_3_1();

            state._fsp--;


            }

             after(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_1_3_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__Group_1_1_3__1__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group__0"
    // InternalSolverLanguageParser.g:9881:1: rule__LowerBoundedScope__Group__0 : rule__LowerBoundedScope__Group__0__Impl rule__LowerBoundedScope__Group__1 ;
    public final void rule__LowerBoundedScope__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9885:1: ( rule__LowerBoundedScope__Group__0__Impl rule__LowerBoundedScope__Group__1 )
            // InternalSolverLanguageParser.g:9886:2: rule__LowerBoundedScope__Group__0__Impl rule__LowerBoundedScope__Group__1
            {
            pushFollow(FOLLOW_70);
            rule__LowerBoundedScope__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group__0"


    // $ANTLR start "rule__LowerBoundedScope__Group__0__Impl"
    // InternalSolverLanguageParser.g:9893:1: rule__LowerBoundedScope__Group__0__Impl : ( Scope ) ;
    public final void rule__LowerBoundedScope__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9897:1: ( ( Scope ) )
            // InternalSolverLanguageParser.g:9898:1: ( Scope )
            {
            // InternalSolverLanguageParser.g:9898:1: ( Scope )
            // InternalSolverLanguageParser.g:9899:2: Scope
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); 
            match(input,Scope,FOLLOW_2); 
             after(grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group__0__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group__1"
    // InternalSolverLanguageParser.g:9908:1: rule__LowerBoundedScope__Group__1 : rule__LowerBoundedScope__Group__1__Impl rule__LowerBoundedScope__Group__2 ;
    public final void rule__LowerBoundedScope__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9912:1: ( rule__LowerBoundedScope__Group__1__Impl rule__LowerBoundedScope__Group__2 )
            // InternalSolverLanguageParser.g:9913:2: rule__LowerBoundedScope__Group__1__Impl rule__LowerBoundedScope__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__LowerBoundedScope__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group__1"


    // $ANTLR start "rule__LowerBoundedScope__Group__1__Impl"
    // InternalSolverLanguageParser.g:9920:1: rule__LowerBoundedScope__Group__1__Impl : ( ( rule__LowerBoundedScope__Alternatives_1 ) ) ;
    public final void rule__LowerBoundedScope__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9924:1: ( ( ( rule__LowerBoundedScope__Alternatives_1 ) ) )
            // InternalSolverLanguageParser.g:9925:1: ( ( rule__LowerBoundedScope__Alternatives_1 ) )
            {
            // InternalSolverLanguageParser.g:9925:1: ( ( rule__LowerBoundedScope__Alternatives_1 ) )
            // InternalSolverLanguageParser.g:9926:2: ( rule__LowerBoundedScope__Alternatives_1 )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getAlternatives_1()); 
            // InternalSolverLanguageParser.g:9927:2: ( rule__LowerBoundedScope__Alternatives_1 )
            // InternalSolverLanguageParser.g:9927:3: rule__LowerBoundedScope__Alternatives_1
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Alternatives_1();

            state._fsp--;


            }

             after(grammarAccess.getLowerBoundedScopeAccess().getAlternatives_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group__1__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group__2"
    // InternalSolverLanguageParser.g:9935:1: rule__LowerBoundedScope__Group__2 : rule__LowerBoundedScope__Group__2__Impl ;
    public final void rule__LowerBoundedScope__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9939:1: ( rule__LowerBoundedScope__Group__2__Impl )
            // InternalSolverLanguageParser.g:9940:2: rule__LowerBoundedScope__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group__2"


    // $ANTLR start "rule__LowerBoundedScope__Group__2__Impl"
    // InternalSolverLanguageParser.g:9946:1: rule__LowerBoundedScope__Group__2__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__LowerBoundedScope__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9950:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:9951:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:9951:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:9952:2: RULE_FULL_STOP
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group__2__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_0__0"
    // InternalSolverLanguageParser.g:9962:1: rule__LowerBoundedScope__Group_1_0__0 : rule__LowerBoundedScope__Group_1_0__0__Impl rule__LowerBoundedScope__Group_1_0__1 ;
    public final void rule__LowerBoundedScope__Group_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9966:1: ( rule__LowerBoundedScope__Group_1_0__0__Impl rule__LowerBoundedScope__Group_1_0__1 )
            // InternalSolverLanguageParser.g:9967:2: rule__LowerBoundedScope__Group_1_0__0__Impl rule__LowerBoundedScope__Group_1_0__1
            {
            pushFollow(FOLLOW_71);
            rule__LowerBoundedScope__Group_1_0__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group_1_0__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_0__0"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_0__0__Impl"
    // InternalSolverLanguageParser.g:9974:1: rule__LowerBoundedScope__Group_1_0__0__Impl : ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 ) ) ;
    public final void rule__LowerBoundedScope__Group_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9978:1: ( ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 ) ) )
            // InternalSolverLanguageParser.g:9979:1: ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 ) )
            {
            // InternalSolverLanguageParser.g:9979:1: ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 ) )
            // InternalSolverLanguageParser.g:9980:2: ( rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_0_0()); 
            // InternalSolverLanguageParser.g:9981:2: ( rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 )
            // InternalSolverLanguageParser.g:9981:3: rule__LowerBoundedScope__LowerBoundAssignment_1_0_0
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__LowerBoundAssignment_1_0_0();

            state._fsp--;


            }

             after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_0__0__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_0__1"
    // InternalSolverLanguageParser.g:9989:1: rule__LowerBoundedScope__Group_1_0__1 : rule__LowerBoundedScope__Group_1_0__1__Impl rule__LowerBoundedScope__Group_1_0__2 ;
    public final void rule__LowerBoundedScope__Group_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:9993:1: ( rule__LowerBoundedScope__Group_1_0__1__Impl rule__LowerBoundedScope__Group_1_0__2 )
            // InternalSolverLanguageParser.g:9994:2: rule__LowerBoundedScope__Group_1_0__1__Impl rule__LowerBoundedScope__Group_1_0__2
            {
            pushFollow(FOLLOW_6);
            rule__LowerBoundedScope__Group_1_0__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group_1_0__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_0__1"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_0__1__Impl"
    // InternalSolverLanguageParser.g:10001:1: rule__LowerBoundedScope__Group_1_0__1__Impl : ( LessThanSignEqualsSign ) ;
    public final void rule__LowerBoundedScope__Group_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10005:1: ( ( LessThanSignEqualsSign ) )
            // InternalSolverLanguageParser.g:10006:1: ( LessThanSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:10006:1: ( LessThanSignEqualsSign )
            // InternalSolverLanguageParser.g:10007:2: LessThanSignEqualsSign
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); 
            match(input,LessThanSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_0__1__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_0__2"
    // InternalSolverLanguageParser.g:10016:1: rule__LowerBoundedScope__Group_1_0__2 : rule__LowerBoundedScope__Group_1_0__2__Impl ;
    public final void rule__LowerBoundedScope__Group_1_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10020:1: ( rule__LowerBoundedScope__Group_1_0__2__Impl )
            // InternalSolverLanguageParser.g:10021:2: rule__LowerBoundedScope__Group_1_0__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group_1_0__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_0__2"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_0__2__Impl"
    // InternalSolverLanguageParser.g:10027:1: rule__LowerBoundedScope__Group_1_0__2__Impl : ( ( rule__LowerBoundedScope__TypeAssignment_1_0_2 ) ) ;
    public final void rule__LowerBoundedScope__Group_1_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10031:1: ( ( ( rule__LowerBoundedScope__TypeAssignment_1_0_2 ) ) )
            // InternalSolverLanguageParser.g:10032:1: ( ( rule__LowerBoundedScope__TypeAssignment_1_0_2 ) )
            {
            // InternalSolverLanguageParser.g:10032:1: ( ( rule__LowerBoundedScope__TypeAssignment_1_0_2 ) )
            // InternalSolverLanguageParser.g:10033:2: ( rule__LowerBoundedScope__TypeAssignment_1_0_2 )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_0_2()); 
            // InternalSolverLanguageParser.g:10034:2: ( rule__LowerBoundedScope__TypeAssignment_1_0_2 )
            // InternalSolverLanguageParser.g:10034:3: rule__LowerBoundedScope__TypeAssignment_1_0_2
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__TypeAssignment_1_0_2();

            state._fsp--;


            }

             after(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_0_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_0__2__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_1__0"
    // InternalSolverLanguageParser.g:10043:1: rule__LowerBoundedScope__Group_1_1__0 : rule__LowerBoundedScope__Group_1_1__0__Impl rule__LowerBoundedScope__Group_1_1__1 ;
    public final void rule__LowerBoundedScope__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10047:1: ( rule__LowerBoundedScope__Group_1_1__0__Impl rule__LowerBoundedScope__Group_1_1__1 )
            // InternalSolverLanguageParser.g:10048:2: rule__LowerBoundedScope__Group_1_1__0__Impl rule__LowerBoundedScope__Group_1_1__1
            {
            pushFollow(FOLLOW_72);
            rule__LowerBoundedScope__Group_1_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group_1_1__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_1__0"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_1__0__Impl"
    // InternalSolverLanguageParser.g:10055:1: rule__LowerBoundedScope__Group_1_1__0__Impl : ( ( rule__LowerBoundedScope__TypeAssignment_1_1_0 ) ) ;
    public final void rule__LowerBoundedScope__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10059:1: ( ( ( rule__LowerBoundedScope__TypeAssignment_1_1_0 ) ) )
            // InternalSolverLanguageParser.g:10060:1: ( ( rule__LowerBoundedScope__TypeAssignment_1_1_0 ) )
            {
            // InternalSolverLanguageParser.g:10060:1: ( ( rule__LowerBoundedScope__TypeAssignment_1_1_0 ) )
            // InternalSolverLanguageParser.g:10061:2: ( rule__LowerBoundedScope__TypeAssignment_1_1_0 )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_1_0()); 
            // InternalSolverLanguageParser.g:10062:2: ( rule__LowerBoundedScope__TypeAssignment_1_1_0 )
            // InternalSolverLanguageParser.g:10062:3: rule__LowerBoundedScope__TypeAssignment_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__TypeAssignment_1_1_0();

            state._fsp--;


            }

             after(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_1__0__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_1__1"
    // InternalSolverLanguageParser.g:10070:1: rule__LowerBoundedScope__Group_1_1__1 : rule__LowerBoundedScope__Group_1_1__1__Impl rule__LowerBoundedScope__Group_1_1__2 ;
    public final void rule__LowerBoundedScope__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10074:1: ( rule__LowerBoundedScope__Group_1_1__1__Impl rule__LowerBoundedScope__Group_1_1__2 )
            // InternalSolverLanguageParser.g:10075:2: rule__LowerBoundedScope__Group_1_1__1__Impl rule__LowerBoundedScope__Group_1_1__2
            {
            pushFollow(FOLLOW_64);
            rule__LowerBoundedScope__Group_1_1__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group_1_1__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_1__1"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_1__1__Impl"
    // InternalSolverLanguageParser.g:10082:1: rule__LowerBoundedScope__Group_1_1__1__Impl : ( GreaterThanSignEqualsSign ) ;
    public final void rule__LowerBoundedScope__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10086:1: ( ( GreaterThanSignEqualsSign ) )
            // InternalSolverLanguageParser.g:10087:1: ( GreaterThanSignEqualsSign )
            {
            // InternalSolverLanguageParser.g:10087:1: ( GreaterThanSignEqualsSign )
            // InternalSolverLanguageParser.g:10088:2: GreaterThanSignEqualsSign
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); 
            match(input,GreaterThanSignEqualsSign,FOLLOW_2); 
             after(grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_1__1__Impl"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_1__2"
    // InternalSolverLanguageParser.g:10097:1: rule__LowerBoundedScope__Group_1_1__2 : rule__LowerBoundedScope__Group_1_1__2__Impl ;
    public final void rule__LowerBoundedScope__Group_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10101:1: ( rule__LowerBoundedScope__Group_1_1__2__Impl )
            // InternalSolverLanguageParser.g:10102:2: rule__LowerBoundedScope__Group_1_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__Group_1_1__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_1__2"


    // $ANTLR start "rule__LowerBoundedScope__Group_1_1__2__Impl"
    // InternalSolverLanguageParser.g:10108:1: rule__LowerBoundedScope__Group_1_1__2__Impl : ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 ) ) ;
    public final void rule__LowerBoundedScope__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10112:1: ( ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 ) ) )
            // InternalSolverLanguageParser.g:10113:1: ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 ) )
            {
            // InternalSolverLanguageParser.g:10113:1: ( ( rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 ) )
            // InternalSolverLanguageParser.g:10114:2: ( rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_1_2()); 
            // InternalSolverLanguageParser.g:10115:2: ( rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 )
            // InternalSolverLanguageParser.g:10115:3: rule__LowerBoundedScope__LowerBoundAssignment_1_1_2
            {
            pushFollow(FOLLOW_2);
            rule__LowerBoundedScope__LowerBoundAssignment_1_1_2();

            state._fsp--;


            }

             after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_1_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__Group_1_1__2__Impl"


    // $ANTLR start "rule__ObjectiveDeclaration__Group__0"
    // InternalSolverLanguageParser.g:10124:1: rule__ObjectiveDeclaration__Group__0 : rule__ObjectiveDeclaration__Group__0__Impl rule__ObjectiveDeclaration__Group__1 ;
    public final void rule__ObjectiveDeclaration__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10128:1: ( rule__ObjectiveDeclaration__Group__0__Impl rule__ObjectiveDeclaration__Group__1 )
            // InternalSolverLanguageParser.g:10129:2: rule__ObjectiveDeclaration__Group__0__Impl rule__ObjectiveDeclaration__Group__1
            {
            pushFollow(FOLLOW_12);
            rule__ObjectiveDeclaration__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ObjectiveDeclaration__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__Group__0"


    // $ANTLR start "rule__ObjectiveDeclaration__Group__0__Impl"
    // InternalSolverLanguageParser.g:10136:1: rule__ObjectiveDeclaration__Group__0__Impl : ( ( rule__ObjectiveDeclaration__KindAssignment_0 ) ) ;
    public final void rule__ObjectiveDeclaration__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10140:1: ( ( ( rule__ObjectiveDeclaration__KindAssignment_0 ) ) )
            // InternalSolverLanguageParser.g:10141:1: ( ( rule__ObjectiveDeclaration__KindAssignment_0 ) )
            {
            // InternalSolverLanguageParser.g:10141:1: ( ( rule__ObjectiveDeclaration__KindAssignment_0 ) )
            // InternalSolverLanguageParser.g:10142:2: ( rule__ObjectiveDeclaration__KindAssignment_0 )
            {
             before(grammarAccess.getObjectiveDeclarationAccess().getKindAssignment_0()); 
            // InternalSolverLanguageParser.g:10143:2: ( rule__ObjectiveDeclaration__KindAssignment_0 )
            // InternalSolverLanguageParser.g:10143:3: rule__ObjectiveDeclaration__KindAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__ObjectiveDeclaration__KindAssignment_0();

            state._fsp--;


            }

             after(grammarAccess.getObjectiveDeclarationAccess().getKindAssignment_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__Group__0__Impl"


    // $ANTLR start "rule__ObjectiveDeclaration__Group__1"
    // InternalSolverLanguageParser.g:10151:1: rule__ObjectiveDeclaration__Group__1 : rule__ObjectiveDeclaration__Group__1__Impl rule__ObjectiveDeclaration__Group__2 ;
    public final void rule__ObjectiveDeclaration__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10155:1: ( rule__ObjectiveDeclaration__Group__1__Impl rule__ObjectiveDeclaration__Group__2 )
            // InternalSolverLanguageParser.g:10156:2: rule__ObjectiveDeclaration__Group__1__Impl rule__ObjectiveDeclaration__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__ObjectiveDeclaration__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__ObjectiveDeclaration__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__Group__1"


    // $ANTLR start "rule__ObjectiveDeclaration__Group__1__Impl"
    // InternalSolverLanguageParser.g:10163:1: rule__ObjectiveDeclaration__Group__1__Impl : ( ( rule__ObjectiveDeclaration__ObjectiveAssignment_1 ) ) ;
    public final void rule__ObjectiveDeclaration__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10167:1: ( ( ( rule__ObjectiveDeclaration__ObjectiveAssignment_1 ) ) )
            // InternalSolverLanguageParser.g:10168:1: ( ( rule__ObjectiveDeclaration__ObjectiveAssignment_1 ) )
            {
            // InternalSolverLanguageParser.g:10168:1: ( ( rule__ObjectiveDeclaration__ObjectiveAssignment_1 ) )
            // InternalSolverLanguageParser.g:10169:2: ( rule__ObjectiveDeclaration__ObjectiveAssignment_1 )
            {
             before(grammarAccess.getObjectiveDeclarationAccess().getObjectiveAssignment_1()); 
            // InternalSolverLanguageParser.g:10170:2: ( rule__ObjectiveDeclaration__ObjectiveAssignment_1 )
            // InternalSolverLanguageParser.g:10170:3: rule__ObjectiveDeclaration__ObjectiveAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ObjectiveDeclaration__ObjectiveAssignment_1();

            state._fsp--;


            }

             after(grammarAccess.getObjectiveDeclarationAccess().getObjectiveAssignment_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__Group__1__Impl"


    // $ANTLR start "rule__ObjectiveDeclaration__Group__2"
    // InternalSolverLanguageParser.g:10178:1: rule__ObjectiveDeclaration__Group__2 : rule__ObjectiveDeclaration__Group__2__Impl ;
    public final void rule__ObjectiveDeclaration__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10182:1: ( rule__ObjectiveDeclaration__Group__2__Impl )
            // InternalSolverLanguageParser.g:10183:2: rule__ObjectiveDeclaration__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ObjectiveDeclaration__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__Group__2"


    // $ANTLR start "rule__ObjectiveDeclaration__Group__2__Impl"
    // InternalSolverLanguageParser.g:10189:1: rule__ObjectiveDeclaration__Group__2__Impl : ( RULE_FULL_STOP ) ;
    public final void rule__ObjectiveDeclaration__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10193:1: ( ( RULE_FULL_STOP ) )
            // InternalSolverLanguageParser.g:10194:1: ( RULE_FULL_STOP )
            {
            // InternalSolverLanguageParser.g:10194:1: ( RULE_FULL_STOP )
            // InternalSolverLanguageParser.g:10195:2: RULE_FULL_STOP
            {
             before(grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); 
            match(input,RULE_FULL_STOP,FOLLOW_2); 
             after(grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__Group__2__Impl"


    // $ANTLR start "rule__Real__Group__0"
    // InternalSolverLanguageParser.g:10205:1: rule__Real__Group__0 : rule__Real__Group__0__Impl rule__Real__Group__1 ;
    public final void rule__Real__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10209:1: ( rule__Real__Group__0__Impl rule__Real__Group__1 )
            // InternalSolverLanguageParser.g:10210:2: rule__Real__Group__0__Impl rule__Real__Group__1
            {
            pushFollow(FOLLOW_49);
            rule__Real__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Real__Group__1();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Real__Group__0"


    // $ANTLR start "rule__Real__Group__0__Impl"
    // InternalSolverLanguageParser.g:10217:1: rule__Real__Group__0__Impl : ( RULE_INT ) ;
    public final void rule__Real__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10221:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:10222:1: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:10222:1: ( RULE_INT )
            // InternalSolverLanguageParser.g:10223:2: RULE_INT
            {
             before(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Real__Group__0__Impl"


    // $ANTLR start "rule__Real__Group__1"
    // InternalSolverLanguageParser.g:10232:1: rule__Real__Group__1 : rule__Real__Group__1__Impl rule__Real__Group__2 ;
    public final void rule__Real__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10236:1: ( rule__Real__Group__1__Impl rule__Real__Group__2 )
            // InternalSolverLanguageParser.g:10237:2: rule__Real__Group__1__Impl rule__Real__Group__2
            {
            pushFollow(FOLLOW_64);
            rule__Real__Group__1__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__Real__Group__2();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Real__Group__1"


    // $ANTLR start "rule__Real__Group__1__Impl"
    // InternalSolverLanguageParser.g:10244:1: rule__Real__Group__1__Impl : ( FullStop ) ;
    public final void rule__Real__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10248:1: ( ( FullStop ) )
            // InternalSolverLanguageParser.g:10249:1: ( FullStop )
            {
            // InternalSolverLanguageParser.g:10249:1: ( FullStop )
            // InternalSolverLanguageParser.g:10250:2: FullStop
            {
             before(grammarAccess.getRealAccess().getFullStopKeyword_1()); 
            match(input,FullStop,FOLLOW_2); 
             after(grammarAccess.getRealAccess().getFullStopKeyword_1()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Real__Group__1__Impl"


    // $ANTLR start "rule__Real__Group__2"
    // InternalSolverLanguageParser.g:10259:1: rule__Real__Group__2 : rule__Real__Group__2__Impl ;
    public final void rule__Real__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10263:1: ( rule__Real__Group__2__Impl )
            // InternalSolverLanguageParser.g:10264:2: rule__Real__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Real__Group__2__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Real__Group__2"


    // $ANTLR start "rule__Real__Group__2__Impl"
    // InternalSolverLanguageParser.g:10270:1: rule__Real__Group__2__Impl : ( RULE_INT ) ;
    public final void rule__Real__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10274:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:10275:1: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:10275:1: ( RULE_INT )
            // InternalSolverLanguageParser.g:10276:2: RULE_INT
            {
             before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Real__Group__2__Impl"


    // $ANTLR start "rule__QualifiedName__Group__0"
    // InternalSolverLanguageParser.g:10286: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 {
            // InternalSolverLanguageParser.g:10290:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 )
            // InternalSolverLanguageParser.g:10291:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1
            {
            pushFollow(FOLLOW_73);
            rule__QualifiedName__Group__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group__1();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:10298:1: rule__QualifiedName__Group__0__Impl : ( ruleQualifiedNameSegment ) ;
    public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10302:1: ( ( ruleQualifiedNameSegment ) )
            // InternalSolverLanguageParser.g:10303:1: ( ruleQualifiedNameSegment )
            {
            // InternalSolverLanguageParser.g:10303:1: ( ruleQualifiedNameSegment )
            // InternalSolverLanguageParser.g:10304:2: ruleQualifiedNameSegment
            {
             before(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedNameSegment();

            state._fsp--;

             after(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_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"
    // InternalSolverLanguageParser.g:10313:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ;
    public final void rule__QualifiedName__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10317:1: ( rule__QualifiedName__Group__1__Impl )
            // InternalSolverLanguageParser.g:10318:2: rule__QualifiedName__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group__1__Impl();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:10324: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 {
            // InternalSolverLanguageParser.g:10328:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) )
            // InternalSolverLanguageParser.g:10329:1: ( ( rule__QualifiedName__Group_1__0 )* )
            {
            // InternalSolverLanguageParser.g:10329:1: ( ( rule__QualifiedName__Group_1__0 )* )
            // InternalSolverLanguageParser.g:10330:2: ( rule__QualifiedName__Group_1__0 )*
            {
             before(grammarAccess.getQualifiedNameAccess().getGroup_1()); 
            // InternalSolverLanguageParser.g:10331:2: ( rule__QualifiedName__Group_1__0 )*
            loop68:
            do {
                int alt68=2;
                int LA68_0 = input.LA(1);

                if ( (LA68_0==ColonColon) ) {
                    alt68=1;
                }


                switch (alt68) {
            	case 1 :
            	    // InternalSolverLanguageParser.g:10331:3: rule__QualifiedName__Group_1__0
            	    {
            	    pushFollow(FOLLOW_74);
            	    rule__QualifiedName__Group_1__0();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop68;
                }
            } while (true);

             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"
    // InternalSolverLanguageParser.g:10340: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 {
            // InternalSolverLanguageParser.g:10344:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 )
            // InternalSolverLanguageParser.g:10345:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1
            {
            pushFollow(FOLLOW_6);
            rule__QualifiedName__Group_1__0__Impl();

            state._fsp--;

            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group_1__1();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:10352:1: rule__QualifiedName__Group_1__0__Impl : ( ColonColon ) ;
    public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10356:1: ( ( ColonColon ) )
            // InternalSolverLanguageParser.g:10357:1: ( ColonColon )
            {
            // InternalSolverLanguageParser.g:10357:1: ( ColonColon )
            // InternalSolverLanguageParser.g:10358:2: ColonColon
            {
             before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); 
            match(input,ColonColon,FOLLOW_2); 
             after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_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"
    // InternalSolverLanguageParser.g:10367: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 {
            // InternalSolverLanguageParser.g:10371:1: ( rule__QualifiedName__Group_1__1__Impl )
            // InternalSolverLanguageParser.g:10372:2: rule__QualifiedName__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__QualifiedName__Group_1__1__Impl();

            state._fsp--;


            }

        }
        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"
    // InternalSolverLanguageParser.g:10378:1: rule__QualifiedName__Group_1__1__Impl : ( ruleQualifiedNameSegment ) ;
    public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10382:1: ( ( ruleQualifiedNameSegment ) )
            // InternalSolverLanguageParser.g:10383:1: ( ruleQualifiedNameSegment )
            {
            // InternalSolverLanguageParser.g:10383:1: ( ruleQualifiedNameSegment )
            // InternalSolverLanguageParser.g:10384:2: ruleQualifiedNameSegment
            {
             before(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedNameSegment();

            state._fsp--;

             after(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_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__ExternPredicateDeclaration__UnorderedGroup_1"
    // InternalSolverLanguageParser.g:10394:1: rule__ExternPredicateDeclaration__UnorderedGroup_1 : ( rule__ExternPredicateDeclaration__UnorderedGroup_1__0 )? ;
    public final void rule__ExternPredicateDeclaration__UnorderedGroup_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        		getUnorderedGroupHelper().enter(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
        	
        try {
            // InternalSolverLanguageParser.g:10399:1: ( ( rule__ExternPredicateDeclaration__UnorderedGroup_1__0 )? )
            // InternalSolverLanguageParser.g:10400:2: ( rule__ExternPredicateDeclaration__UnorderedGroup_1__0 )?
            {
            // InternalSolverLanguageParser.g:10400:2: ( rule__ExternPredicateDeclaration__UnorderedGroup_1__0 )?
            int alt69=2;
            int LA69_0 = input.LA(1);

            if ( LA69_0 == Functional && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0) ) {
                alt69=1;
            }
            else if ( LA69_0 == Error && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1) ) {
                alt69=1;
            }
            switch (alt69) {
                case 1 :
                    // InternalSolverLanguageParser.g:10400:2: rule__ExternPredicateDeclaration__UnorderedGroup_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ExternPredicateDeclaration__UnorderedGroup_1__0();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	getUnorderedGroupHelper().leave(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__UnorderedGroup_1"


    // $ANTLR start "rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl"
    // InternalSolverLanguageParser.g:10408:1: rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl : ( ({...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) ) ) | ({...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) ) ) ) ;
    public final void rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        		boolean selected = false;
        	
        try {
            // InternalSolverLanguageParser.g:10413:1: ( ( ({...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) ) ) | ({...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) ) ) ) )
            // InternalSolverLanguageParser.g:10414:3: ( ({...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) ) ) | ({...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) ) ) )
            {
            // InternalSolverLanguageParser.g:10414:3: ( ({...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) ) ) | ({...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) ) ) )
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( LA70_0 == Functional && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0) ) {
                alt70=1;
            }
            else if ( LA70_0 == Error && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1) ) {
                alt70=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 70, 0, input);

                throw nvae;
            }
            switch (alt70) {
                case 1 :
                    // InternalSolverLanguageParser.g:10415:3: ({...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) ) )
                    {
                    // InternalSolverLanguageParser.g:10415:3: ({...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) ) )
                    // InternalSolverLanguageParser.g:10416:4: {...}? => ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) )
                    {
                    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0) ) {
                        throw new FailedPredicateException(input, "rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0)");
                    }
                    // InternalSolverLanguageParser.g:10416:122: ( ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) ) )
                    // InternalSolverLanguageParser.g:10417:5: ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) )
                    {

                    					getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0);
                    				

                    					selected = true;
                    				
                    // InternalSolverLanguageParser.g:10423:5: ( ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 ) )
                    // InternalSolverLanguageParser.g:10424:6: ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 )
                    {
                     before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalAssignment_1_0()); 
                    // InternalSolverLanguageParser.g:10425:6: ( rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 )
                    // InternalSolverLanguageParser.g:10425:7: rule__ExternPredicateDeclaration__FunctionalAssignment_1_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ExternPredicateDeclaration__FunctionalAssignment_1_0();

                    state._fsp--;


                    }

                     after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalAssignment_1_0()); 

                    }


                    }


                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:10430:3: ({...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) ) )
                    {
                    // InternalSolverLanguageParser.g:10430:3: ({...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) ) )
                    // InternalSolverLanguageParser.g:10431:4: {...}? => ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) )
                    {
                    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1) ) {
                        throw new FailedPredicateException(input, "rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1)");
                    }
                    // InternalSolverLanguageParser.g:10431:122: ( ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) ) )
                    // InternalSolverLanguageParser.g:10432:5: ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) )
                    {

                    					getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1);
                    				

                    					selected = true;
                    				
                    // InternalSolverLanguageParser.g:10438:5: ( ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 ) )
                    // InternalSolverLanguageParser.g:10439:6: ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 )
                    {
                     before(grammarAccess.getExternPredicateDeclarationAccess().getErrorAssignment_1_1()); 
                    // InternalSolverLanguageParser.g:10440:6: ( rule__ExternPredicateDeclaration__ErrorAssignment_1_1 )
                    // InternalSolverLanguageParser.g:10440:7: rule__ExternPredicateDeclaration__ErrorAssignment_1_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ExternPredicateDeclaration__ErrorAssignment_1_1();

                    state._fsp--;


                    }

                     after(grammarAccess.getExternPredicateDeclarationAccess().getErrorAssignment_1_1()); 

                    }


                    }


                    }


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	if (selected)
            		getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl"


    // $ANTLR start "rule__ExternPredicateDeclaration__UnorderedGroup_1__0"
    // InternalSolverLanguageParser.g:10453:1: rule__ExternPredicateDeclaration__UnorderedGroup_1__0 : rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl ( rule__ExternPredicateDeclaration__UnorderedGroup_1__1 )? ;
    public final void rule__ExternPredicateDeclaration__UnorderedGroup_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10457:1: ( rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl ( rule__ExternPredicateDeclaration__UnorderedGroup_1__1 )? )
            // InternalSolverLanguageParser.g:10458:2: rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl ( rule__ExternPredicateDeclaration__UnorderedGroup_1__1 )?
            {
            pushFollow(FOLLOW_75);
            rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl();

            state._fsp--;

            // InternalSolverLanguageParser.g:10459:2: ( rule__ExternPredicateDeclaration__UnorderedGroup_1__1 )?
            int alt71=2;
            int LA71_0 = input.LA(1);

            if ( LA71_0 == Functional && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0) ) {
                alt71=1;
            }
            else if ( LA71_0 == Error && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1) ) {
                alt71=1;
            }
            switch (alt71) {
                case 1 :
                    // InternalSolverLanguageParser.g:10459:2: rule__ExternPredicateDeclaration__UnorderedGroup_1__1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ExternPredicateDeclaration__UnorderedGroup_1__1();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__UnorderedGroup_1__0"


    // $ANTLR start "rule__ExternPredicateDeclaration__UnorderedGroup_1__1"
    // InternalSolverLanguageParser.g:10465:1: rule__ExternPredicateDeclaration__UnorderedGroup_1__1 : rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl ;
    public final void rule__ExternPredicateDeclaration__UnorderedGroup_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10469:1: ( rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl )
            // InternalSolverLanguageParser.g:10470:2: rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__UnorderedGroup_1__1"


    // $ANTLR start "rule__ClassDeclaration__UnorderedGroup_0"
    // InternalSolverLanguageParser.g:10477:1: rule__ClassDeclaration__UnorderedGroup_0 : ( rule__ClassDeclaration__UnorderedGroup_0__0 )? ;
    public final void rule__ClassDeclaration__UnorderedGroup_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        		getUnorderedGroupHelper().enter(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
        	
        try {
            // InternalSolverLanguageParser.g:10482:1: ( ( rule__ClassDeclaration__UnorderedGroup_0__0 )? )
            // InternalSolverLanguageParser.g:10483:2: ( rule__ClassDeclaration__UnorderedGroup_0__0 )?
            {
            // InternalSolverLanguageParser.g:10483:2: ( rule__ClassDeclaration__UnorderedGroup_0__0 )?
            int alt72=2;
            int LA72_0 = input.LA(1);

            if ( LA72_0 == Abstract && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0) ) {
                alt72=1;
            }
            else if ( LA72_0 == Root && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1) ) {
                alt72=1;
            }
            switch (alt72) {
                case 1 :
                    // InternalSolverLanguageParser.g:10483:2: rule__ClassDeclaration__UnorderedGroup_0__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassDeclaration__UnorderedGroup_0__0();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	getUnorderedGroupHelper().leave(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__UnorderedGroup_0"


    // $ANTLR start "rule__ClassDeclaration__UnorderedGroup_0__Impl"
    // InternalSolverLanguageParser.g:10491:1: rule__ClassDeclaration__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) ) ) ) ;
    public final void rule__ClassDeclaration__UnorderedGroup_0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        		boolean selected = false;
        	
        try {
            // InternalSolverLanguageParser.g:10496:1: ( ( ({...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) ) ) ) )
            // InternalSolverLanguageParser.g:10497:3: ( ({...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) ) ) )
            {
            // InternalSolverLanguageParser.g:10497:3: ( ({...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) ) ) )
            int alt73=2;
            int LA73_0 = input.LA(1);

            if ( LA73_0 == Abstract && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0) ) {
                alt73=1;
            }
            else if ( LA73_0 == Root && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1) ) {
                alt73=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 73, 0, input);

                throw nvae;
            }
            switch (alt73) {
                case 1 :
                    // InternalSolverLanguageParser.g:10498:3: ({...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) ) )
                    {
                    // InternalSolverLanguageParser.g:10498:3: ({...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) ) )
                    // InternalSolverLanguageParser.g:10499:4: {...}? => ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) )
                    {
                    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0) ) {
                        throw new FailedPredicateException(input, "rule__ClassDeclaration__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0)");
                    }
                    // InternalSolverLanguageParser.g:10499:112: ( ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) ) )
                    // InternalSolverLanguageParser.g:10500:5: ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) )
                    {

                    					getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0);
                    				

                    					selected = true;
                    				
                    // InternalSolverLanguageParser.g:10506:5: ( ( rule__ClassDeclaration__AbstractAssignment_0_0 ) )
                    // InternalSolverLanguageParser.g:10507:6: ( rule__ClassDeclaration__AbstractAssignment_0_0 )
                    {
                     before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0_0()); 
                    // InternalSolverLanguageParser.g:10508:6: ( rule__ClassDeclaration__AbstractAssignment_0_0 )
                    // InternalSolverLanguageParser.g:10508:7: rule__ClassDeclaration__AbstractAssignment_0_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassDeclaration__AbstractAssignment_0_0();

                    state._fsp--;


                    }

                     after(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0_0()); 

                    }


                    }


                    }


                    }
                    break;
                case 2 :
                    // InternalSolverLanguageParser.g:10513:3: ({...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) ) )
                    {
                    // InternalSolverLanguageParser.g:10513:3: ({...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) ) )
                    // InternalSolverLanguageParser.g:10514:4: {...}? => ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) )
                    {
                    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1) ) {
                        throw new FailedPredicateException(input, "rule__ClassDeclaration__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1)");
                    }
                    // InternalSolverLanguageParser.g:10514:112: ( ( ( rule__ClassDeclaration__RootAssignment_0_1 ) ) )
                    // InternalSolverLanguageParser.g:10515:5: ( ( rule__ClassDeclaration__RootAssignment_0_1 ) )
                    {

                    					getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1);
                    				

                    					selected = true;
                    				
                    // InternalSolverLanguageParser.g:10521:5: ( ( rule__ClassDeclaration__RootAssignment_0_1 ) )
                    // InternalSolverLanguageParser.g:10522:6: ( rule__ClassDeclaration__RootAssignment_0_1 )
                    {
                     before(grammarAccess.getClassDeclarationAccess().getRootAssignment_0_1()); 
                    // InternalSolverLanguageParser.g:10523:6: ( rule__ClassDeclaration__RootAssignment_0_1 )
                    // InternalSolverLanguageParser.g:10523:7: rule__ClassDeclaration__RootAssignment_0_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassDeclaration__RootAssignment_0_1();

                    state._fsp--;


                    }

                     after(grammarAccess.getClassDeclarationAccess().getRootAssignment_0_1()); 

                    }


                    }


                    }


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	if (selected)
            		getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__UnorderedGroup_0__Impl"


    // $ANTLR start "rule__ClassDeclaration__UnorderedGroup_0__0"
    // InternalSolverLanguageParser.g:10536:1: rule__ClassDeclaration__UnorderedGroup_0__0 : rule__ClassDeclaration__UnorderedGroup_0__Impl ( rule__ClassDeclaration__UnorderedGroup_0__1 )? ;
    public final void rule__ClassDeclaration__UnorderedGroup_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10540:1: ( rule__ClassDeclaration__UnorderedGroup_0__Impl ( rule__ClassDeclaration__UnorderedGroup_0__1 )? )
            // InternalSolverLanguageParser.g:10541:2: rule__ClassDeclaration__UnorderedGroup_0__Impl ( rule__ClassDeclaration__UnorderedGroup_0__1 )?
            {
            pushFollow(FOLLOW_76);
            rule__ClassDeclaration__UnorderedGroup_0__Impl();

            state._fsp--;

            // InternalSolverLanguageParser.g:10542:2: ( rule__ClassDeclaration__UnorderedGroup_0__1 )?
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( LA74_0 == Abstract && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0) ) {
                alt74=1;
            }
            else if ( LA74_0 == Root && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1) ) {
                alt74=1;
            }
            switch (alt74) {
                case 1 :
                    // InternalSolverLanguageParser.g:10542:2: rule__ClassDeclaration__UnorderedGroup_0__1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassDeclaration__UnorderedGroup_0__1();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__UnorderedGroup_0__0"


    // $ANTLR start "rule__ClassDeclaration__UnorderedGroup_0__1"
    // InternalSolverLanguageParser.g:10548:1: rule__ClassDeclaration__UnorderedGroup_0__1 : rule__ClassDeclaration__UnorderedGroup_0__Impl ;
    public final void rule__ClassDeclaration__UnorderedGroup_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10552:1: ( rule__ClassDeclaration__UnorderedGroup_0__Impl )
            // InternalSolverLanguageParser.g:10553:2: rule__ClassDeclaration__UnorderedGroup_0__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassDeclaration__UnorderedGroup_0__Impl();

            state._fsp--;


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__UnorderedGroup_0__1"


    // $ANTLR start "rule__Problem__NameAssignment_0_1"
    // InternalSolverLanguageParser.g:10560:1: rule__Problem__NameAssignment_0_1 : ( ruleQualifiedName ) ;
    public final void rule__Problem__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10564:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10565:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:10565:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10566:3: ruleQualifiedName
            {
             before(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Problem__NameAssignment_0_1"


    // $ANTLR start "rule__Problem__ImportsAssignment_1"
    // InternalSolverLanguageParser.g:10575:1: rule__Problem__ImportsAssignment_1 : ( ruleImport ) ;
    public final void rule__Problem__ImportsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10579:1: ( ( ruleImport ) )
            // InternalSolverLanguageParser.g:10580:2: ( ruleImport )
            {
            // InternalSolverLanguageParser.g:10580:2: ( ruleImport )
            // InternalSolverLanguageParser.g:10581:3: ruleImport
            {
             before(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleImport();

            state._fsp--;

             after(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Problem__ImportsAssignment_1"


    // $ANTLR start "rule__Problem__StatementsAssignment_2"
    // InternalSolverLanguageParser.g:10590:1: rule__Problem__StatementsAssignment_2 : ( ruleStatement ) ;
    public final void rule__Problem__StatementsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10594:1: ( ( ruleStatement ) )
            // InternalSolverLanguageParser.g:10595:2: ( ruleStatement )
            {
            // InternalSolverLanguageParser.g:10595:2: ( ruleStatement )
            // InternalSolverLanguageParser.g:10596:3: ruleStatement
            {
             before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleStatement();

            state._fsp--;

             after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Problem__StatementsAssignment_2"


    // $ANTLR start "rule__UriImport__UriAssignment_1"
    // InternalSolverLanguageParser.g:10605:1: rule__UriImport__UriAssignment_1 : ( RULE_STRING ) ;
    public final void rule__UriImport__UriAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10609:1: ( ( RULE_STRING ) )
            // InternalSolverLanguageParser.g:10610:2: ( RULE_STRING )
            {
            // InternalSolverLanguageParser.g:10610:2: ( RULE_STRING )
            // InternalSolverLanguageParser.g:10611:3: RULE_STRING
            {
             before(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); 
            match(input,RULE_STRING,FOLLOW_2); 
             after(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UriImport__UriAssignment_1"


    // $ANTLR start "rule__UriImport__AliasAssignment_2_1"
    // InternalSolverLanguageParser.g:10620:1: rule__UriImport__AliasAssignment_2_1 : ( ruleQualifiedName ) ;
    public final void rule__UriImport__AliasAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10624:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10625:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:10625:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10626:3: ruleQualifiedName
            {
             before(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UriImport__AliasAssignment_2_1"


    // $ANTLR start "rule__NamespaceImport__ImportedNamespaceAssignment_1"
    // InternalSolverLanguageParser.g:10635:1: rule__NamespaceImport__ImportedNamespaceAssignment_1 : ( ruleQualifiedName ) ;
    public final void rule__NamespaceImport__ImportedNamespaceAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10639:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10640:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:10640:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10641:3: ruleQualifiedName
            {
             before(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NamespaceImport__ImportedNamespaceAssignment_1"


    // $ANTLR start "rule__NamespaceImport__AliasAssignment_2_1"
    // InternalSolverLanguageParser.g:10650:1: rule__NamespaceImport__AliasAssignment_2_1 : ( ruleQualifiedName ) ;
    public final void rule__NamespaceImport__AliasAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10654:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10655:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:10655:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10656:3: ruleQualifiedName
            {
             before(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NamespaceImport__AliasAssignment_2_1"


    // $ANTLR start "rule__AssertionOrDefinition__RangeAssignment_1_0_1_1"
    // InternalSolverLanguageParser.g:10665:1: rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 : ( ruleExpression ) ;
    public final void rule__AssertionOrDefinition__RangeAssignment_1_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10669:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10670:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10670:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10671:3: ruleExpression
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AssertionOrDefinition__RangeAssignment_1_0_1_1"


    // $ANTLR start "rule__AssertionOrDefinition__BodyAssignment_1_1_2"
    // InternalSolverLanguageParser.g:10680:1: rule__AssertionOrDefinition__BodyAssignment_1_1_2 : ( ruleExpression ) ;
    public final void rule__AssertionOrDefinition__BodyAssignment_1_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10684:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10685:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10685:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10686:3: ruleExpression
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AssertionOrDefinition__BodyAssignment_1_1_2"


    // $ANTLR start "rule__AssertionOrDefinition__BodyAssignment_1_2_2"
    // InternalSolverLanguageParser.g:10695:1: rule__AssertionOrDefinition__BodyAssignment_1_2_2 : ( ruleExpression ) ;
    public final void rule__AssertionOrDefinition__BodyAssignment_1_2_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10699:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10700:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10700:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10701:3: ruleExpression
            {
             before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AssertionOrDefinition__BodyAssignment_1_2_2"


    // $ANTLR start "rule__PredicateDefinition__FunctionalAssignment_0_0_0"
    // InternalSolverLanguageParser.g:10710:1: rule__PredicateDefinition__FunctionalAssignment_0_0_0 : ( ( Functional ) ) ;
    public final void rule__PredicateDefinition__FunctionalAssignment_0_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10714:1: ( ( ( Functional ) ) )
            // InternalSolverLanguageParser.g:10715:2: ( ( Functional ) )
            {
            // InternalSolverLanguageParser.g:10715:2: ( ( Functional ) )
            // InternalSolverLanguageParser.g:10716:3: ( Functional )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); 
            // InternalSolverLanguageParser.g:10717:3: ( Functional )
            // InternalSolverLanguageParser.g:10718:4: Functional
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); 
            match(input,Functional,FOLLOW_2); 
             after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); 

            }

             after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PredicateDefinition__FunctionalAssignment_0_0_0"


    // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_0_1"
    // InternalSolverLanguageParser.g:10729:1: rule__PredicateDefinition__ErrorAssignment_0_0_1 : ( ( Error ) ) ;
    public final void rule__PredicateDefinition__ErrorAssignment_0_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10733:1: ( ( ( Error ) ) )
            // InternalSolverLanguageParser.g:10734:2: ( ( Error ) )
            {
            // InternalSolverLanguageParser.g:10734:2: ( ( Error ) )
            // InternalSolverLanguageParser.g:10735:3: ( Error )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); 
            // InternalSolverLanguageParser.g:10736:3: ( Error )
            // InternalSolverLanguageParser.g:10737:4: Error
            {
             before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); 
            match(input,Error,FOLLOW_2); 
             after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); 

            }

             after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PredicateDefinition__ErrorAssignment_0_0_1"


    // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_1_0"
    // InternalSolverLanguageParser.g:10748:1: rule__PredicateDefinition__ErrorAssignment_0_1_0 : ( ( Error ) ) ;
    public final void rule__PredicateDefinition__ErrorAssignment_0_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10752:1: ( ( ( Error ) ) )
            // InternalSolverLanguageParser.g:10753:2: ( ( Error ) )
            {
            // InternalSolverLanguageParser.g:10753:2: ( ( Error ) )
            // InternalSolverLanguageParser.g:10754:3: ( Error )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); 
            // InternalSolverLanguageParser.g:10755:3: ( Error )
            // InternalSolverLanguageParser.g:10756:4: Error
            {
             before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); 
            match(input,Error,FOLLOW_2); 
             after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); 

            }

             after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PredicateDefinition__ErrorAssignment_0_1_0"


    // $ANTLR start "rule__PredicateDefinition__FunctionalAssignment_0_1_1"
    // InternalSolverLanguageParser.g:10767:1: rule__PredicateDefinition__FunctionalAssignment_0_1_1 : ( ( Functional ) ) ;
    public final void rule__PredicateDefinition__FunctionalAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10771:1: ( ( ( Functional ) ) )
            // InternalSolverLanguageParser.g:10772:2: ( ( Functional ) )
            {
            // InternalSolverLanguageParser.g:10772:2: ( ( Functional ) )
            // InternalSolverLanguageParser.g:10773:3: ( Functional )
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); 
            // InternalSolverLanguageParser.g:10774:3: ( Functional )
            // InternalSolverLanguageParser.g:10775:4: Functional
            {
             before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); 
            match(input,Functional,FOLLOW_2); 
             after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); 

            }

             after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PredicateDefinition__FunctionalAssignment_0_1_1"


    // $ANTLR start "rule__PredicateDefinition__HeadAssignment_1"
    // InternalSolverLanguageParser.g:10786:1: rule__PredicateDefinition__HeadAssignment_1 : ( ruleCall ) ;
    public final void rule__PredicateDefinition__HeadAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10790:1: ( ( ruleCall ) )
            // InternalSolverLanguageParser.g:10791:2: ( ruleCall )
            {
            // InternalSolverLanguageParser.g:10791:2: ( ruleCall )
            // InternalSolverLanguageParser.g:10792:3: ruleCall
            {
             before(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleCall();

            state._fsp--;

             after(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PredicateDefinition__HeadAssignment_1"


    // $ANTLR start "rule__PredicateDefinition__BodyAssignment_3"
    // InternalSolverLanguageParser.g:10801:1: rule__PredicateDefinition__BodyAssignment_3 : ( ruleExpression ) ;
    public final void rule__PredicateDefinition__BodyAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10805:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10806:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10806:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10807:3: ruleExpression
            {
             before(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PredicateDefinition__BodyAssignment_3"


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1"
    // InternalSolverLanguageParser.g:10816:1: rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1 : ( ruleArgumentList ) ;
    public final void rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10820:1: ( ( ruleArgumentList ) )
            // InternalSolverLanguageParser.g:10821:2: ( ruleArgumentList )
            {
            // InternalSolverLanguageParser.g:10821:2: ( ruleArgumentList )
            // InternalSolverLanguageParser.g:10822:3: ruleArgumentList
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleArgumentList();

            state._fsp--;

             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1"


    // $ANTLR start "rule__UnnamedErrorPredicateDefintion__BodyAssignment_3"
    // InternalSolverLanguageParser.g:10831:1: rule__UnnamedErrorPredicateDefintion__BodyAssignment_3 : ( ruleExpression ) ;
    public final void rule__UnnamedErrorPredicateDefintion__BodyAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10835:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10836:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10836:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10837:3: ruleExpression
            {
             before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnnamedErrorPredicateDefintion__BodyAssignment_3"


    // $ANTLR start "rule__DefaultAssertion__ExpressionAssignment_1"
    // InternalSolverLanguageParser.g:10846:1: rule__DefaultAssertion__ExpressionAssignment_1 : ( ruleCall ) ;
    public final void rule__DefaultAssertion__ExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10850:1: ( ( ruleCall ) )
            // InternalSolverLanguageParser.g:10851:2: ( ruleCall )
            {
            // InternalSolverLanguageParser.g:10851:2: ( ruleCall )
            // InternalSolverLanguageParser.g:10852:3: ruleCall
            {
             before(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleCall();

            state._fsp--;

             after(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultAssertion__ExpressionAssignment_1"


    // $ANTLR start "rule__DefaultAssertion__RangeAssignment_2_1"
    // InternalSolverLanguageParser.g:10861:1: rule__DefaultAssertion__RangeAssignment_2_1 : ( ruleExpression ) ;
    public final void rule__DefaultAssertion__RangeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10865:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10866:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10866:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10867:3: ruleExpression
            {
             before(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DefaultAssertion__RangeAssignment_2_1"


    // $ANTLR start "rule__FunctionDefinition__ResultTypeAssignment_0"
    // InternalSolverLanguageParser.g:10876:1: rule__FunctionDefinition__ResultTypeAssignment_0 : ( ( ruleQualifiedName ) ) ;
    public final void rule__FunctionDefinition__ResultTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10880:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:10881:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:10881:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10882:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); 
            // InternalSolverLanguageParser.g:10883:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10884:4: ruleQualifiedName
            {
             before(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1()); 

            }

             after(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionDefinition__ResultTypeAssignment_0"


    // $ANTLR start "rule__FunctionDefinition__HeadAssignment_1"
    // InternalSolverLanguageParser.g:10895:1: rule__FunctionDefinition__HeadAssignment_1 : ( ruleCall ) ;
    public final void rule__FunctionDefinition__HeadAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10899:1: ( ( ruleCall ) )
            // InternalSolverLanguageParser.g:10900:2: ( ruleCall )
            {
            // InternalSolverLanguageParser.g:10900:2: ( ruleCall )
            // InternalSolverLanguageParser.g:10901:3: ruleCall
            {
             before(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleCall();

            state._fsp--;

             after(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionDefinition__HeadAssignment_1"


    // $ANTLR start "rule__FunctionDefinition__BodyAssignment_3"
    // InternalSolverLanguageParser.g:10910:1: rule__FunctionDefinition__BodyAssignment_3 : ( ruleExpression ) ;
    public final void rule__FunctionDefinition__BodyAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10914:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:10915:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:10915:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:10916:3: ruleExpression
            {
             before(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FunctionDefinition__BodyAssignment_3"


    // $ANTLR start "rule__TypeReference__TypeAssignment_0"
    // InternalSolverLanguageParser.g:10925:1: rule__TypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ;
    public final void rule__TypeReference__TypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10929:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:10930:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:10930:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10931:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); 
            // InternalSolverLanguageParser.g:10932:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10933:4: ruleQualifiedName
            {
             before(grammarAccess.getTypeReferenceAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getTypeReferenceAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); 

            }

             after(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeReference__TypeAssignment_0"


    // $ANTLR start "rule__TypeReference__ForceObjectTypeAssignment_1"
    // InternalSolverLanguageParser.g:10944:1: rule__TypeReference__ForceObjectTypeAssignment_1 : ( ( Object ) ) ;
    public final void rule__TypeReference__ForceObjectTypeAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10948:1: ( ( ( Object ) ) )
            // InternalSolverLanguageParser.g:10949:2: ( ( Object ) )
            {
            // InternalSolverLanguageParser.g:10949:2: ( ( Object ) )
            // InternalSolverLanguageParser.g:10950:3: ( Object )
            {
             before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); 
            // InternalSolverLanguageParser.g:10951:3: ( Object )
            // InternalSolverLanguageParser.g:10952:4: Object
            {
             before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); 
            match(input,Object,FOLLOW_2); 
             after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); 

            }

             after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeReference__ForceObjectTypeAssignment_1"


    // $ANTLR start "rule__Attribute__KindAssignment_0"
    // InternalSolverLanguageParser.g:10963:1: rule__Attribute__KindAssignment_0 : ( ruleAttributeKind ) ;
    public final void rule__Attribute__KindAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10967:1: ( ( ruleAttributeKind ) )
            // InternalSolverLanguageParser.g:10968:2: ( ruleAttributeKind )
            {
            // InternalSolverLanguageParser.g:10968:2: ( ruleAttributeKind )
            // InternalSolverLanguageParser.g:10969:3: ruleAttributeKind
            {
             before(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            ruleAttributeKind();

            state._fsp--;

             after(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Attribute__KindAssignment_0"


    // $ANTLR start "rule__Attribute__TargetAssignment_1"
    // InternalSolverLanguageParser.g:10978:1: rule__Attribute__TargetAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__Attribute__TargetAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:10982:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:10983:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:10983:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:10984:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); 
            // InternalSolverLanguageParser.g:10985:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:10986:4: ruleQualifiedName
            {
             before(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1()); 

            }

             after(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Attribute__TargetAssignment_1"


    // $ANTLR start "rule__ExternPredicateDeclaration__FunctionalAssignment_1_0"
    // InternalSolverLanguageParser.g:10997:1: rule__ExternPredicateDeclaration__FunctionalAssignment_1_0 : ( ( Functional ) ) ;
    public final void rule__ExternPredicateDeclaration__FunctionalAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11001:1: ( ( ( Functional ) ) )
            // InternalSolverLanguageParser.g:11002:2: ( ( Functional ) )
            {
            // InternalSolverLanguageParser.g:11002:2: ( ( Functional ) )
            // InternalSolverLanguageParser.g:11003:3: ( Functional )
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); 
            // InternalSolverLanguageParser.g:11004:3: ( Functional )
            // InternalSolverLanguageParser.g:11005:4: Functional
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); 
            match(input,Functional,FOLLOW_2); 
             after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); 

            }

             after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__FunctionalAssignment_1_0"


    // $ANTLR start "rule__ExternPredicateDeclaration__ErrorAssignment_1_1"
    // InternalSolverLanguageParser.g:11016:1: rule__ExternPredicateDeclaration__ErrorAssignment_1_1 : ( ( Error ) ) ;
    public final void rule__ExternPredicateDeclaration__ErrorAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11020:1: ( ( ( Error ) ) )
            // InternalSolverLanguageParser.g:11021:2: ( ( Error ) )
            {
            // InternalSolverLanguageParser.g:11021:2: ( ( Error ) )
            // InternalSolverLanguageParser.g:11022:3: ( Error )
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); 
            // InternalSolverLanguageParser.g:11023:3: ( Error )
            // InternalSolverLanguageParser.g:11024:4: Error
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); 
            match(input,Error,FOLLOW_2); 
             after(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); 

            }

             after(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__ErrorAssignment_1_1"


    // $ANTLR start "rule__ExternPredicateDeclaration__NameAssignment_2"
    // InternalSolverLanguageParser.g:11035:1: rule__ExternPredicateDeclaration__NameAssignment_2 : ( ruleQualifiedName ) ;
    public final void rule__ExternPredicateDeclaration__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11039:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11040:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:11040:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11041:3: ruleQualifiedName
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__NameAssignment_2"


    // $ANTLR start "rule__ExternPredicateDeclaration__ArgumentListAssignment_3"
    // InternalSolverLanguageParser.g:11050:1: rule__ExternPredicateDeclaration__ArgumentListAssignment_3 : ( ruleArgumentList ) ;
    public final void rule__ExternPredicateDeclaration__ArgumentListAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11054:1: ( ( ruleArgumentList ) )
            // InternalSolverLanguageParser.g:11055:2: ( ruleArgumentList )
            {
            // InternalSolverLanguageParser.g:11055:2: ( ruleArgumentList )
            // InternalSolverLanguageParser.g:11056:3: ruleArgumentList
            {
             before(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleArgumentList();

            state._fsp--;

             after(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternPredicateDeclaration__ArgumentListAssignment_3"


    // $ANTLR start "rule__ExternFunctionDeclaration__ResultTypeAssignment_1"
    // InternalSolverLanguageParser.g:11065:1: rule__ExternFunctionDeclaration__ResultTypeAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ExternFunctionDeclaration__ResultTypeAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11069:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11070:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11070:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11071:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); 
            // InternalSolverLanguageParser.g:11072:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11073:4: ruleQualifiedName
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 

            }

             after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternFunctionDeclaration__ResultTypeAssignment_1"


    // $ANTLR start "rule__ExternFunctionDeclaration__NameAssignment_2"
    // InternalSolverLanguageParser.g:11084:1: rule__ExternFunctionDeclaration__NameAssignment_2 : ( ruleQualifiedName ) ;
    public final void rule__ExternFunctionDeclaration__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11088:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11089:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:11089:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11090:3: ruleQualifiedName
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternFunctionDeclaration__NameAssignment_2"


    // $ANTLR start "rule__ExternFunctionDeclaration__ArgumentListAssignment_3"
    // InternalSolverLanguageParser.g:11099:1: rule__ExternFunctionDeclaration__ArgumentListAssignment_3 : ( ruleArgumentList ) ;
    public final void rule__ExternFunctionDeclaration__ArgumentListAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11103:1: ( ( ruleArgumentList ) )
            // InternalSolverLanguageParser.g:11104:2: ( ruleArgumentList )
            {
            // InternalSolverLanguageParser.g:11104:2: ( ruleArgumentList )
            // InternalSolverLanguageParser.g:11105:3: ruleArgumentList
            {
             before(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleArgumentList();

            state._fsp--;

             after(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternFunctionDeclaration__ArgumentListAssignment_3"


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1"
    // InternalSolverLanguageParser.g:11114:1: rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11118:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11119:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11119:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11120:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); 
            // InternalSolverLanguageParser.g:11121:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11122:4: ruleQualifiedName
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 

            }

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1"


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__NameAssignment_2"
    // InternalSolverLanguageParser.g:11133:1: rule__ExternAggregationOperatorDeclaration__NameAssignment_2 : ( ruleQualifiedName ) ;
    public final void rule__ExternAggregationOperatorDeclaration__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11137:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11138:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:11138:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11139:3: ruleQualifiedName
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternAggregationOperatorDeclaration__NameAssignment_2"


    // $ANTLR start "rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4"
    // InternalSolverLanguageParser.g:11148:1: rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11152:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11153:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11153:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11154:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); 
            // InternalSolverLanguageParser.g:11155:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11156:4: ruleQualifiedName
            {
             before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1()); 

            }

             after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4"


    // $ANTLR start "rule__ExternDatatypeDeclaration__NameAssignment_2"
    // InternalSolverLanguageParser.g:11167:1: rule__ExternDatatypeDeclaration__NameAssignment_2 : ( ruleQualifiedName ) ;
    public final void rule__ExternDatatypeDeclaration__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11171:1: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11172:2: ( ruleQualifiedName )
            {
            // InternalSolverLanguageParser.g:11172:2: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11173:3: ruleQualifiedName
            {
             before(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExternDatatypeDeclaration__NameAssignment_2"


    // $ANTLR start "rule__Expression__BodyAssignment_2_1_2"
    // InternalSolverLanguageParser.g:11182:1: rule__Expression__BodyAssignment_2_1_2 : ( ruleDisjunctiveExpression ) ;
    public final void rule__Expression__BodyAssignment_2_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11186:1: ( ( ruleDisjunctiveExpression ) )
            // InternalSolverLanguageParser.g:11187:2: ( ruleDisjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:11187:2: ( ruleDisjunctiveExpression )
            // InternalSolverLanguageParser.g:11188:3: ruleDisjunctiveExpression
            {
             before(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleDisjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Expression__BodyAssignment_2_1_2"


    // $ANTLR start "rule__ConditionalExpression__ConditionAssignment_1"
    // InternalSolverLanguageParser.g:11197:1: rule__ConditionalExpression__ConditionAssignment_1 : ( ruleDisjunctiveExpression ) ;
    public final void rule__ConditionalExpression__ConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11201:1: ( ( ruleDisjunctiveExpression ) )
            // InternalSolverLanguageParser.g:11202:2: ( ruleDisjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:11202:2: ( ruleDisjunctiveExpression )
            // InternalSolverLanguageParser.g:11203:3: ruleDisjunctiveExpression
            {
             before(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleDisjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConditionalExpression__ConditionAssignment_1"


    // $ANTLR start "rule__ConditionalExpression__ThenAssignment_3"
    // InternalSolverLanguageParser.g:11212:1: rule__ConditionalExpression__ThenAssignment_3 : ( ruleExpression ) ;
    public final void rule__ConditionalExpression__ThenAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11216:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:11217:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:11217:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:11218:3: ruleExpression
            {
             before(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConditionalExpression__ThenAssignment_3"


    // $ANTLR start "rule__ConditionalExpression__ElseAssignment_5"
    // InternalSolverLanguageParser.g:11227:1: rule__ConditionalExpression__ElseAssignment_5 : ( ruleExpression ) ;
    public final void rule__ConditionalExpression__ElseAssignment_5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11231:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:11232:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:11232:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:11233:3: ruleExpression
            {
             before(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConditionalExpression__ElseAssignment_5"


    // $ANTLR start "rule__LetExpression__BindingsAssignment_1"
    // InternalSolverLanguageParser.g:11242:1: rule__LetExpression__BindingsAssignment_1 : ( ruleLetBinding ) ;
    public final void rule__LetExpression__BindingsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11246:1: ( ( ruleLetBinding ) )
            // InternalSolverLanguageParser.g:11247:2: ( ruleLetBinding )
            {
            // InternalSolverLanguageParser.g:11247:2: ( ruleLetBinding )
            // InternalSolverLanguageParser.g:11248:3: ruleLetBinding
            {
             before(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleLetBinding();

            state._fsp--;

             after(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpression__BindingsAssignment_1"


    // $ANTLR start "rule__LetExpression__BindingsAssignment_2_1"
    // InternalSolverLanguageParser.g:11257:1: rule__LetExpression__BindingsAssignment_2_1 : ( ruleLetBinding ) ;
    public final void rule__LetExpression__BindingsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11261:1: ( ( ruleLetBinding ) )
            // InternalSolverLanguageParser.g:11262:2: ( ruleLetBinding )
            {
            // InternalSolverLanguageParser.g:11262:2: ( ruleLetBinding )
            // InternalSolverLanguageParser.g:11263:3: ruleLetBinding
            {
             before(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); 
            pushFollow(FOLLOW_2);
            ruleLetBinding();

            state._fsp--;

             after(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpression__BindingsAssignment_2_1"


    // $ANTLR start "rule__LetExpression__BodyAssignment_4"
    // InternalSolverLanguageParser.g:11272:1: rule__LetExpression__BodyAssignment_4 : ( ruleExpression ) ;
    public final void rule__LetExpression__BodyAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11276:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:11277:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:11277:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:11278:3: ruleExpression
            {
             before(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpression__BodyAssignment_4"


    // $ANTLR start "rule__LetBinding__TypeAssignment_0"
    // InternalSolverLanguageParser.g:11287:1: rule__LetBinding__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ;
    public final void rule__LetBinding__TypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11291:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11292:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11292:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11293:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); 
            // InternalSolverLanguageParser.g:11294:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11295:4: ruleQualifiedName
            {
             before(grammarAccess.getLetBindingAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getLetBindingAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); 

            }

             after(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetBinding__TypeAssignment_0"


    // $ANTLR start "rule__LetBinding__NameAssignment_1"
    // InternalSolverLanguageParser.g:11306:1: rule__LetBinding__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__LetBinding__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11310:1: ( ( RULE_ID ) )
            // InternalSolverLanguageParser.g:11311:2: ( RULE_ID )
            {
            // InternalSolverLanguageParser.g:11311:2: ( RULE_ID )
            // InternalSolverLanguageParser.g:11312:3: RULE_ID
            {
             before(grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); 
            match(input,RULE_ID,FOLLOW_2); 
             after(grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetBinding__NameAssignment_1"


    // $ANTLR start "rule__LetBinding__ValueAssignment_3"
    // InternalSolverLanguageParser.g:11321:1: rule__LetBinding__ValueAssignment_3 : ( ruleAdditiveExpression ) ;
    public final void rule__LetBinding__ValueAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11325:1: ( ( ruleAdditiveExpression ) )
            // InternalSolverLanguageParser.g:11326:2: ( ruleAdditiveExpression )
            {
            // InternalSolverLanguageParser.g:11326:2: ( ruleAdditiveExpression )
            // InternalSolverLanguageParser.g:11327:3: ruleAdditiveExpression
            {
             before(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleAdditiveExpression();

            state._fsp--;

             after(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetBinding__ValueAssignment_3"


    // $ANTLR start "rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1"
    // InternalSolverLanguageParser.g:11336:1: rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 : ( ruleConjunctiveExpression ) ;
    public final void rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11340:1: ( ( ruleConjunctiveExpression ) )
            // InternalSolverLanguageParser.g:11341:2: ( ruleConjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:11341:2: ( ruleConjunctiveExpression )
            // InternalSolverLanguageParser.g:11342:3: ruleConjunctiveExpression
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleConjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1"


    // $ANTLR start "rule__DisjunctiveExpression__BodyAssignment_1_1_2"
    // InternalSolverLanguageParser.g:11351:1: rule__DisjunctiveExpression__BodyAssignment_1_1_2 : ( ruleConjunctiveExpression ) ;
    public final void rule__DisjunctiveExpression__BodyAssignment_1_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11355:1: ( ( ruleConjunctiveExpression ) )
            // InternalSolverLanguageParser.g:11356:2: ( ruleConjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:11356:2: ( ruleConjunctiveExpression )
            // InternalSolverLanguageParser.g:11357:3: ruleConjunctiveExpression
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleConjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DisjunctiveExpression__BodyAssignment_1_1_2"


    // $ANTLR start "rule__DisjunctiveExpression__CasesAssignment_1_1_4_1"
    // InternalSolverLanguageParser.g:11366:1: rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 : ( ruleCase ) ;
    public final void rule__DisjunctiveExpression__CasesAssignment_1_1_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11370:1: ( ( ruleCase ) )
            // InternalSolverLanguageParser.g:11371:2: ( ruleCase )
            {
            // InternalSolverLanguageParser.g:11371:2: ( ruleCase )
            // InternalSolverLanguageParser.g:11372:3: ruleCase
            {
             before(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); 
            pushFollow(FOLLOW_2);
            ruleCase();

            state._fsp--;

             after(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DisjunctiveExpression__CasesAssignment_1_1_4_1"


    // $ANTLR start "rule__Case__ConditionAssignment_0"
    // InternalSolverLanguageParser.g:11381:1: rule__Case__ConditionAssignment_0 : ( ruleConjunctiveExpression ) ;
    public final void rule__Case__ConditionAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11385:1: ( ( ruleConjunctiveExpression ) )
            // InternalSolverLanguageParser.g:11386:2: ( ruleConjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:11386:2: ( ruleConjunctiveExpression )
            // InternalSolverLanguageParser.g:11387:3: ruleConjunctiveExpression
            {
             before(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            ruleConjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__ConditionAssignment_0"


    // $ANTLR start "rule__Case__BodyAssignment_2"
    // InternalSolverLanguageParser.g:11396:1: rule__Case__BodyAssignment_2 : ( ruleConjunctiveExpression ) ;
    public final void rule__Case__BodyAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11400:1: ( ( ruleConjunctiveExpression ) )
            // InternalSolverLanguageParser.g:11401:2: ( ruleConjunctiveExpression )
            {
            // InternalSolverLanguageParser.g:11401:2: ( ruleConjunctiveExpression )
            // InternalSolverLanguageParser.g:11402:3: ruleConjunctiveExpression
            {
             before(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleConjunctiveExpression();

            state._fsp--;

             after(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Case__BodyAssignment_2"


    // $ANTLR start "rule__ConjunctiveExpression__ChildrenAssignment_1_1_1"
    // InternalSolverLanguageParser.g:11411:1: rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 : ( ruleComparisonExpression ) ;
    public final void rule__ConjunctiveExpression__ChildrenAssignment_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11415:1: ( ( ruleComparisonExpression ) )
            // InternalSolverLanguageParser.g:11416:2: ( ruleComparisonExpression )
            {
            // InternalSolverLanguageParser.g:11416:2: ( ruleComparisonExpression )
            // InternalSolverLanguageParser.g:11417:3: ruleComparisonExpression
            {
             before(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleComparisonExpression();

            state._fsp--;

             after(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConjunctiveExpression__ChildrenAssignment_1_1_1"


    // $ANTLR start "rule__ComparisonExpression__OpAssignment_1_1"
    // InternalSolverLanguageParser.g:11426:1: rule__ComparisonExpression__OpAssignment_1_1 : ( ruleComparisonOperator ) ;
    public final void rule__ComparisonExpression__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11430:1: ( ( ruleComparisonOperator ) )
            // InternalSolverLanguageParser.g:11431:2: ( ruleComparisonOperator )
            {
            // InternalSolverLanguageParser.g:11431:2: ( ruleComparisonOperator )
            // InternalSolverLanguageParser.g:11432:3: ruleComparisonOperator
            {
             before(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleComparisonOperator();

            state._fsp--;

             after(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ComparisonExpression__OpAssignment_1_1"


    // $ANTLR start "rule__ComparisonExpression__RightAssignment_1_2"
    // InternalSolverLanguageParser.g:11441:1: rule__ComparisonExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ;
    public final void rule__ComparisonExpression__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11445:1: ( ( ruleAdditiveExpression ) )
            // InternalSolverLanguageParser.g:11446:2: ( ruleAdditiveExpression )
            {
            // InternalSolverLanguageParser.g:11446:2: ( ruleAdditiveExpression )
            // InternalSolverLanguageParser.g:11447:3: ruleAdditiveExpression
            {
             before(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleAdditiveExpression();

            state._fsp--;

             after(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ComparisonExpression__RightAssignment_1_2"


    // $ANTLR start "rule__AdditiveExpression__OpAssignment_1_1"
    // InternalSolverLanguageParser.g:11456:1: rule__AdditiveExpression__OpAssignment_1_1 : ( ruleAdditiveBinaryOperator ) ;
    public final void rule__AdditiveExpression__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11460:1: ( ( ruleAdditiveBinaryOperator ) )
            // InternalSolverLanguageParser.g:11461:2: ( ruleAdditiveBinaryOperator )
            {
            // InternalSolverLanguageParser.g:11461:2: ( ruleAdditiveBinaryOperator )
            // InternalSolverLanguageParser.g:11462:3: ruleAdditiveBinaryOperator
            {
             before(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleAdditiveBinaryOperator();

            state._fsp--;

             after(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__OpAssignment_1_1"


    // $ANTLR start "rule__AdditiveExpression__RightAssignment_1_2"
    // InternalSolverLanguageParser.g:11471:1: rule__AdditiveExpression__RightAssignment_1_2 : ( ruleMultiplicativeExpression ) ;
    public final void rule__AdditiveExpression__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11475:1: ( ( ruleMultiplicativeExpression ) )
            // InternalSolverLanguageParser.g:11476:2: ( ruleMultiplicativeExpression )
            {
            // InternalSolverLanguageParser.g:11476:2: ( ruleMultiplicativeExpression )
            // InternalSolverLanguageParser.g:11477:3: ruleMultiplicativeExpression
            {
             before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleMultiplicativeExpression();

            state._fsp--;

             after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AdditiveExpression__RightAssignment_1_2"


    // $ANTLR start "rule__MultiplicativeExpression__OpAssignment_1_1"
    // InternalSolverLanguageParser.g:11486:1: rule__MultiplicativeExpression__OpAssignment_1_1 : ( ruleMultiplicativeBinaryOperator ) ;
    public final void rule__MultiplicativeExpression__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11490:1: ( ( ruleMultiplicativeBinaryOperator ) )
            // InternalSolverLanguageParser.g:11491:2: ( ruleMultiplicativeBinaryOperator )
            {
            // InternalSolverLanguageParser.g:11491:2: ( ruleMultiplicativeBinaryOperator )
            // InternalSolverLanguageParser.g:11492:3: ruleMultiplicativeBinaryOperator
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleMultiplicativeBinaryOperator();

            state._fsp--;

             after(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__OpAssignment_1_1"


    // $ANTLR start "rule__MultiplicativeExpression__RightAssignment_1_2"
    // InternalSolverLanguageParser.g:11501:1: rule__MultiplicativeExpression__RightAssignment_1_2 : ( ruleExponentialExpression ) ;
    public final void rule__MultiplicativeExpression__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11505:1: ( ( ruleExponentialExpression ) )
            // InternalSolverLanguageParser.g:11506:2: ( ruleExponentialExpression )
            {
            // InternalSolverLanguageParser.g:11506:2: ( ruleExponentialExpression )
            // InternalSolverLanguageParser.g:11507:3: ruleExponentialExpression
            {
             before(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleExponentialExpression();

            state._fsp--;

             after(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicativeExpression__RightAssignment_1_2"


    // $ANTLR start "rule__ExponentialExpression__OpAssignment_1_1"
    // InternalSolverLanguageParser.g:11516:1: rule__ExponentialExpression__OpAssignment_1_1 : ( ruleExponentialOp ) ;
    public final void rule__ExponentialExpression__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11520:1: ( ( ruleExponentialOp ) )
            // InternalSolverLanguageParser.g:11521:2: ( ruleExponentialOp )
            {
            // InternalSolverLanguageParser.g:11521:2: ( ruleExponentialOp )
            // InternalSolverLanguageParser.g:11522:3: ruleExponentialOp
            {
             before(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleExponentialOp();

            state._fsp--;

             after(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__OpAssignment_1_1"


    // $ANTLR start "rule__ExponentialExpression__RightAssignment_1_2"
    // InternalSolverLanguageParser.g:11531:1: rule__ExponentialExpression__RightAssignment_1_2 : ( ruleCastExpression ) ;
    public final void rule__ExponentialExpression__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11535:1: ( ( ruleCastExpression ) )
            // InternalSolverLanguageParser.g:11536:2: ( ruleCastExpression )
            {
            // InternalSolverLanguageParser.g:11536:2: ( ruleCastExpression )
            // InternalSolverLanguageParser.g:11537:3: ruleCastExpression
            {
             before(grammarAccess.getExponentialExpressionAccess().getRightCastExpressionParserRuleCall_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleCastExpression();

            state._fsp--;

             after(grammarAccess.getExponentialExpressionAccess().getRightCastExpressionParserRuleCall_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExponentialExpression__RightAssignment_1_2"


    // $ANTLR start "rule__CastExpression__TargetTypeAssignment_1_2"
    // InternalSolverLanguageParser.g:11546:1: rule__CastExpression__TargetTypeAssignment_1_2 : ( ( ruleQualifiedName ) ) ;
    public final void rule__CastExpression__TargetTypeAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11550:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11551:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11551:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11552:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); 
            // InternalSolverLanguageParser.g:11553:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11554:4: ruleQualifiedName
            {
             before(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1()); 

            }

             after(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CastExpression__TargetTypeAssignment_1_2"


    // $ANTLR start "rule__UnaryExpression__OpAssignment_1_1"
    // InternalSolverLanguageParser.g:11565:1: rule__UnaryExpression__OpAssignment_1_1 : ( ruleUnaryOperator ) ;
    public final void rule__UnaryExpression__OpAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11569:1: ( ( ruleUnaryOperator ) )
            // InternalSolverLanguageParser.g:11570:2: ( ruleUnaryOperator )
            {
            // InternalSolverLanguageParser.g:11570:2: ( ruleUnaryOperator )
            // InternalSolverLanguageParser.g:11571:3: ruleUnaryOperator
            {
             before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleUnaryOperator();

            state._fsp--;

             after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__OpAssignment_1_1"


    // $ANTLR start "rule__UnaryExpression__BodyAssignment_1_2"
    // InternalSolverLanguageParser.g:11580:1: rule__UnaryExpression__BodyAssignment_1_2 : ( ruleBracedAggregateExpression ) ;
    public final void rule__UnaryExpression__BodyAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11584:1: ( ( ruleBracedAggregateExpression ) )
            // InternalSolverLanguageParser.g:11585:2: ( ruleBracedAggregateExpression )
            {
            // InternalSolverLanguageParser.g:11585:2: ( ruleBracedAggregateExpression )
            // InternalSolverLanguageParser.g:11586:3: ruleBracedAggregateExpression
            {
             before(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); 
            pushFollow(FOLLOW_2);
            ruleBracedAggregateExpression();

            state._fsp--;

             after(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnaryExpression__BodyAssignment_1_2"


    // $ANTLR start "rule__Aggregation__OpAssignment_0"
    // InternalSolverLanguageParser.g:11595:1: rule__Aggregation__OpAssignment_0 : ( ( ruleQualifiedName ) ) ;
    public final void rule__Aggregation__OpAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11599:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11600:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11600:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11601:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); 
            // InternalSolverLanguageParser.g:11602:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11603:4: ruleQualifiedName
            {
             before(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1()); 

            }

             after(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__OpAssignment_0"


    // $ANTLR start "rule__Aggregation__ValueAssignment_2"
    // InternalSolverLanguageParser.g:11614:1: rule__Aggregation__ValueAssignment_2 : ( ruleExpression ) ;
    public final void rule__Aggregation__ValueAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11618:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:11619:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:11619:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:11620:3: ruleExpression
            {
             before(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__ValueAssignment_2"


    // $ANTLR start "rule__Aggregation__ConditionAssignment_4"
    // InternalSolverLanguageParser.g:11629:1: rule__Aggregation__ConditionAssignment_4 : ( ruleExpression ) ;
    public final void rule__Aggregation__ConditionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11633:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:11634:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:11634:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:11635:3: ruleExpression
            {
             before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Aggregation__ConditionAssignment_4"


    // $ANTLR start "rule__Count__ConditionAssignment_2"
    // InternalSolverLanguageParser.g:11644:1: rule__Count__ConditionAssignment_2 : ( ruleExpression ) ;
    public final void rule__Count__ConditionAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11648:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:11649:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:11649:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:11650:3: ruleExpression
            {
             before(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Count__ConditionAssignment_2"


    // $ANTLR start "rule__Call__FunctorAssignment_0"
    // InternalSolverLanguageParser.g:11659:1: rule__Call__FunctorAssignment_0 : ( ruleReference ) ;
    public final void rule__Call__FunctorAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11663:1: ( ( ruleReference ) )
            // InternalSolverLanguageParser.g:11664:2: ( ruleReference )
            {
            // InternalSolverLanguageParser.g:11664:2: ( ruleReference )
            // InternalSolverLanguageParser.g:11665:3: ruleReference
            {
             before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            ruleReference();

            state._fsp--;

             after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Call__FunctorAssignment_0"


    // $ANTLR start "rule__Call__ArgumentListAssignment_1"
    // InternalSolverLanguageParser.g:11674:1: rule__Call__ArgumentListAssignment_1 : ( ruleArgumentList ) ;
    public final void rule__Call__ArgumentListAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11678:1: ( ( ruleArgumentList ) )
            // InternalSolverLanguageParser.g:11679:2: ( ruleArgumentList )
            {
            // InternalSolverLanguageParser.g:11679:2: ( ruleArgumentList )
            // InternalSolverLanguageParser.g:11680:3: ruleArgumentList
            {
             before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleArgumentList();

            state._fsp--;

             after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Call__ArgumentListAssignment_1"


    // $ANTLR start "rule__ArgumentList__ArgumentsAssignment_2_0"
    // InternalSolverLanguageParser.g:11689:1: rule__ArgumentList__ArgumentsAssignment_2_0 : ( ruleArgument ) ;
    public final void rule__ArgumentList__ArgumentsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11693:1: ( ( ruleArgument ) )
            // InternalSolverLanguageParser.g:11694:2: ( ruleArgument )
            {
            // InternalSolverLanguageParser.g:11694:2: ( ruleArgument )
            // InternalSolverLanguageParser.g:11695:3: ruleArgument
            {
             before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); 
            pushFollow(FOLLOW_2);
            ruleArgument();

            state._fsp--;

             after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__ArgumentsAssignment_2_0"


    // $ANTLR start "rule__ArgumentList__ArgumentsAssignment_2_1_1"
    // InternalSolverLanguageParser.g:11704:1: rule__ArgumentList__ArgumentsAssignment_2_1_1 : ( ruleArgument ) ;
    public final void rule__ArgumentList__ArgumentsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11708:1: ( ( ruleArgument ) )
            // InternalSolverLanguageParser.g:11709:2: ( ruleArgument )
            {
            // InternalSolverLanguageParser.g:11709:2: ( ruleArgument )
            // InternalSolverLanguageParser.g:11710:3: ruleArgument
            {
             before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleArgument();

            state._fsp--;

             after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ArgumentList__ArgumentsAssignment_2_1_1"


    // $ANTLR start "rule__ExpressionArgument__ExpressionAssignment"
    // InternalSolverLanguageParser.g:11719:1: rule__ExpressionArgument__ExpressionAssignment : ( ruleComparisonExpression ) ;
    public final void rule__ExpressionArgument__ExpressionAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11723:1: ( ( ruleComparisonExpression ) )
            // InternalSolverLanguageParser.g:11724:2: ( ruleComparisonExpression )
            {
            // InternalSolverLanguageParser.g:11724:2: ( ruleComparisonExpression )
            // InternalSolverLanguageParser.g:11725:3: ruleComparisonExpression
            {
             before(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleComparisonExpression();

            state._fsp--;

             after(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpressionArgument__ExpressionAssignment"


    // $ANTLR start "rule__TypedVariableArgument__TypeReferenceAssignment_0"
    // InternalSolverLanguageParser.g:11734:1: rule__TypedVariableArgument__TypeReferenceAssignment_0 : ( ruleTypeReference ) ;
    public final void rule__TypedVariableArgument__TypeReferenceAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11738:1: ( ( ruleTypeReference ) )
            // InternalSolverLanguageParser.g:11739:2: ( ruleTypeReference )
            {
            // InternalSolverLanguageParser.g:11739:2: ( ruleTypeReference )
            // InternalSolverLanguageParser.g:11740:3: ruleTypeReference
            {
             before(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            ruleTypeReference();

            state._fsp--;

             after(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedVariableArgument__TypeReferenceAssignment_0"


    // $ANTLR start "rule__TypedVariableArgument__NameAssignment_1"
    // InternalSolverLanguageParser.g:11749:1: rule__TypedVariableArgument__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__TypedVariableArgument__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11753:1: ( ( RULE_ID ) )
            // InternalSolverLanguageParser.g:11754:2: ( RULE_ID )
            {
            // InternalSolverLanguageParser.g:11754:2: ( RULE_ID )
            // InternalSolverLanguageParser.g:11755:3: RULE_ID
            {
             before(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); 
            match(input,RULE_ID,FOLLOW_2); 
             after(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedVariableArgument__NameAssignment_1"


    // $ANTLR start "rule__TypedStarArgument__TypeReferenceAssignment_0"
    // InternalSolverLanguageParser.g:11764:1: rule__TypedStarArgument__TypeReferenceAssignment_0 : ( ruleTypeReference ) ;
    public final void rule__TypedStarArgument__TypeReferenceAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11768:1: ( ( ruleTypeReference ) )
            // InternalSolverLanguageParser.g:11769:2: ( ruleTypeReference )
            {
            // InternalSolverLanguageParser.g:11769:2: ( ruleTypeReference )
            // InternalSolverLanguageParser.g:11770:3: ruleTypeReference
            {
             before(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            ruleTypeReference();

            state._fsp--;

             after(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedStarArgument__TypeReferenceAssignment_0"


    // $ANTLR start "rule__Reference__ComponentsAssignment_0"
    // InternalSolverLanguageParser.g:11779:1: rule__Reference__ComponentsAssignment_0 : ( rulePathComponent ) ;
    public final void rule__Reference__ComponentsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11783:1: ( ( rulePathComponent ) )
            // InternalSolverLanguageParser.g:11784:2: ( rulePathComponent )
            {
            // InternalSolverLanguageParser.g:11784:2: ( rulePathComponent )
            // InternalSolverLanguageParser.g:11785:3: rulePathComponent
            {
             before(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            rulePathComponent();

            state._fsp--;

             after(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__ComponentsAssignment_0"


    // $ANTLR start "rule__Reference__ComponentsAssignment_1_1"
    // InternalSolverLanguageParser.g:11794:1: rule__Reference__ComponentsAssignment_1_1 : ( rulePathComponent ) ;
    public final void rule__Reference__ComponentsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11798:1: ( ( rulePathComponent ) )
            // InternalSolverLanguageParser.g:11799:2: ( rulePathComponent )
            {
            // InternalSolverLanguageParser.g:11799:2: ( rulePathComponent )
            // InternalSolverLanguageParser.g:11800:3: rulePathComponent
            {
             before(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); 
            pushFollow(FOLLOW_2);
            rulePathComponent();

            state._fsp--;

             after(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Reference__ComponentsAssignment_1_1"


    // $ANTLR start "rule__PathComponent__InverseAssignment_0"
    // InternalSolverLanguageParser.g:11809:1: rule__PathComponent__InverseAssignment_0 : ( ( Tilde ) ) ;
    public final void rule__PathComponent__InverseAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11813:1: ( ( ( Tilde ) ) )
            // InternalSolverLanguageParser.g:11814:2: ( ( Tilde ) )
            {
            // InternalSolverLanguageParser.g:11814:2: ( ( Tilde ) )
            // InternalSolverLanguageParser.g:11815:3: ( Tilde )
            {
             before(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); 
            // InternalSolverLanguageParser.g:11816:3: ( Tilde )
            // InternalSolverLanguageParser.g:11817:4: Tilde
            {
             before(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); 
            match(input,Tilde,FOLLOW_2); 
             after(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); 

            }

             after(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__InverseAssignment_0"


    // $ANTLR start "rule__PathComponent__SymbolAssignment_1"
    // InternalSolverLanguageParser.g:11828:1: rule__PathComponent__SymbolAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__PathComponent__SymbolAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11832:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:11833:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:11833:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:11834:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); 
            // InternalSolverLanguageParser.g:11835:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:11836:4: ruleQualifiedName
            {
             before(grammarAccess.getPathComponentAccess().getSymbolSymbolQualifiedNameParserRuleCall_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getPathComponentAccess().getSymbolSymbolQualifiedNameParserRuleCall_1_0_1()); 

            }

             after(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__SymbolAssignment_1"


    // $ANTLR start "rule__PathComponent__TransitiveClosureAssignment_2_0"
    // InternalSolverLanguageParser.g:11847:1: rule__PathComponent__TransitiveClosureAssignment_2_0 : ( RULE_TRANSITIVE_CLOSURE ) ;
    public final void rule__PathComponent__TransitiveClosureAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11851:1: ( ( RULE_TRANSITIVE_CLOSURE ) )
            // InternalSolverLanguageParser.g:11852:2: ( RULE_TRANSITIVE_CLOSURE )
            {
            // InternalSolverLanguageParser.g:11852:2: ( RULE_TRANSITIVE_CLOSURE )
            // InternalSolverLanguageParser.g:11853:3: RULE_TRANSITIVE_CLOSURE
            {
             before(grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); 
            match(input,RULE_TRANSITIVE_CLOSURE,FOLLOW_2); 
             after(grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__TransitiveClosureAssignment_2_0"


    // $ANTLR start "rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1"
    // InternalSolverLanguageParser.g:11862:1: rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1 : ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ;
    public final void rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11866:1: ( ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) )
            // InternalSolverLanguageParser.g:11867:2: ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE )
            {
            // InternalSolverLanguageParser.g:11867:2: ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE )
            // InternalSolverLanguageParser.g:11868:3: RULE_REFLEXIVE_TRANSITIVE_CLOSURE
            {
             before(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); 
            match(input,RULE_REFLEXIVE_TRANSITIVE_CLOSURE,FOLLOW_2); 
             after(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1"


    // $ANTLR start "rule__Interval__LowerBoundAssignment_1"
    // InternalSolverLanguageParser.g:11877:1: rule__Interval__LowerBoundAssignment_1 : ( ruleAdditiveExpression ) ;
    public final void rule__Interval__LowerBoundAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11881:1: ( ( ruleAdditiveExpression ) )
            // InternalSolverLanguageParser.g:11882:2: ( ruleAdditiveExpression )
            {
            // InternalSolverLanguageParser.g:11882:2: ( ruleAdditiveExpression )
            // InternalSolverLanguageParser.g:11883:3: ruleAdditiveExpression
            {
             before(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleAdditiveExpression();

            state._fsp--;

             after(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__LowerBoundAssignment_1"


    // $ANTLR start "rule__Interval__UpperBoundAssignment_3"
    // InternalSolverLanguageParser.g:11892:1: rule__Interval__UpperBoundAssignment_3 : ( ruleAdditiveExpression ) ;
    public final void rule__Interval__UpperBoundAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11896:1: ( ( ruleAdditiveExpression ) )
            // InternalSolverLanguageParser.g:11897:2: ( ruleAdditiveExpression )
            {
            // InternalSolverLanguageParser.g:11897:2: ( ruleAdditiveExpression )
            // InternalSolverLanguageParser.g:11898:3: ruleAdditiveExpression
            {
             before(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleAdditiveExpression();

            state._fsp--;

             after(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Interval__UpperBoundAssignment_3"


    // $ANTLR start "rule__LogicLiteral__ValueAssignment"
    // InternalSolverLanguageParser.g:11907:1: rule__LogicLiteral__ValueAssignment : ( ruleLogicValue ) ;
    public final void rule__LogicLiteral__ValueAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11911:1: ( ( ruleLogicValue ) )
            // InternalSolverLanguageParser.g:11912:2: ( ruleLogicValue )
            {
            // InternalSolverLanguageParser.g:11912:2: ( ruleLogicValue )
            // InternalSolverLanguageParser.g:11913:3: ruleLogicValue
            {
             before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleLogicValue();

            state._fsp--;

             after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LogicLiteral__ValueAssignment"


    // $ANTLR start "rule__IntLiteral__ValueAssignment"
    // InternalSolverLanguageParser.g:11922:1: rule__IntLiteral__ValueAssignment : ( RULE_INT ) ;
    public final void rule__IntLiteral__ValueAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11926:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:11927:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:11927:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:11928:3: RULE_INT
            {
             before(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IntLiteral__ValueAssignment"


    // $ANTLR start "rule__RealLiteral__ValueAssignment"
    // InternalSolverLanguageParser.g:11937:1: rule__RealLiteral__ValueAssignment : ( ruleReal ) ;
    public final void rule__RealLiteral__ValueAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11941:1: ( ( ruleReal ) )
            // InternalSolverLanguageParser.g:11942:2: ( ruleReal )
            {
            // InternalSolverLanguageParser.g:11942:2: ( ruleReal )
            // InternalSolverLanguageParser.g:11943:3: ruleReal
            {
             before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); 
            pushFollow(FOLLOW_2);
            ruleReal();

            state._fsp--;

             after(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RealLiteral__ValueAssignment"


    // $ANTLR start "rule__StringLiteral__ValueAssignment"
    // InternalSolverLanguageParser.g:11952:1: rule__StringLiteral__ValueAssignment : ( RULE_STRING ) ;
    public final void rule__StringLiteral__ValueAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11956:1: ( ( RULE_STRING ) )
            // InternalSolverLanguageParser.g:11957:2: ( RULE_STRING )
            {
            // InternalSolverLanguageParser.g:11957:2: ( RULE_STRING )
            // InternalSolverLanguageParser.g:11958:3: RULE_STRING
            {
             before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); 
            match(input,RULE_STRING,FOLLOW_2); 
             after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StringLiteral__ValueAssignment"


    // $ANTLR start "rule__ClassDeclaration__AbstractAssignment_0_0"
    // InternalSolverLanguageParser.g:11967:1: rule__ClassDeclaration__AbstractAssignment_0_0 : ( ( Abstract ) ) ;
    public final void rule__ClassDeclaration__AbstractAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11971:1: ( ( ( Abstract ) ) )
            // InternalSolverLanguageParser.g:11972:2: ( ( Abstract ) )
            {
            // InternalSolverLanguageParser.g:11972:2: ( ( Abstract ) )
            // InternalSolverLanguageParser.g:11973:3: ( Abstract )
            {
             before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); 
            // InternalSolverLanguageParser.g:11974:3: ( Abstract )
            // InternalSolverLanguageParser.g:11975:4: Abstract
            {
             before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); 
            match(input,Abstract,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); 

            }

             after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__AbstractAssignment_0_0"


    // $ANTLR start "rule__ClassDeclaration__RootAssignment_0_1"
    // InternalSolverLanguageParser.g:11986:1: rule__ClassDeclaration__RootAssignment_0_1 : ( ( Root ) ) ;
    public final void rule__ClassDeclaration__RootAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:11990:1: ( ( ( Root ) ) )
            // InternalSolverLanguageParser.g:11991:2: ( ( Root ) )
            {
            // InternalSolverLanguageParser.g:11991:2: ( ( Root ) )
            // InternalSolverLanguageParser.g:11992:3: ( Root )
            {
             before(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); 
            // InternalSolverLanguageParser.g:11993:3: ( Root )
            // InternalSolverLanguageParser.g:11994:4: Root
            {
             before(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); 
            match(input,Root,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); 

            }

             after(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__RootAssignment_0_1"


    // $ANTLR start "rule__ClassDeclaration__NameAssignment_2"
    // InternalSolverLanguageParser.g:12005:1: rule__ClassDeclaration__NameAssignment_2 : ( RULE_ID ) ;
    public final void rule__ClassDeclaration__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12009:1: ( ( RULE_ID ) )
            // InternalSolverLanguageParser.g:12010:2: ( RULE_ID )
            {
            // InternalSolverLanguageParser.g:12010:2: ( RULE_ID )
            // InternalSolverLanguageParser.g:12011:3: RULE_ID
            {
             before(grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); 
            match(input,RULE_ID,FOLLOW_2); 
             after(grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__NameAssignment_2"


    // $ANTLR start "rule__ClassDeclaration__SupertypesAssignment_3_1"
    // InternalSolverLanguageParser.g:12020:1: rule__ClassDeclaration__SupertypesAssignment_3_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ClassDeclaration__SupertypesAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12024:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12025:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12025:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12026:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); 
            // InternalSolverLanguageParser.g:12027:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12028:4: ruleQualifiedName
            {
             before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1()); 

            }

             after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__SupertypesAssignment_3_1"


    // $ANTLR start "rule__ClassDeclaration__SupertypesAssignment_3_2_1"
    // InternalSolverLanguageParser.g:12039:1: rule__ClassDeclaration__SupertypesAssignment_3_2_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ClassDeclaration__SupertypesAssignment_3_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12043:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12044:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12044:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12045:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); 
            // InternalSolverLanguageParser.g:12046:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12047:4: ruleQualifiedName
            {
             before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1()); 

            }

             after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__SupertypesAssignment_3_2_1"


    // $ANTLR start "rule__ClassDeclaration__FieldsAssignment_4_0_1"
    // InternalSolverLanguageParser.g:12058:1: rule__ClassDeclaration__FieldsAssignment_4_0_1 : ( ruleField ) ;
    public final void rule__ClassDeclaration__FieldsAssignment_4_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12062:1: ( ( ruleField ) )
            // InternalSolverLanguageParser.g:12063:2: ( ruleField )
            {
            // InternalSolverLanguageParser.g:12063:2: ( ruleField )
            // InternalSolverLanguageParser.g:12064:3: ruleField
            {
             before(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); 
            pushFollow(FOLLOW_2);
            ruleField();

            state._fsp--;

             after(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassDeclaration__FieldsAssignment_4_0_1"


    // $ANTLR start "rule__Field__ContainmentAssignment_0_0"
    // InternalSolverLanguageParser.g:12073:1: rule__Field__ContainmentAssignment_0_0 : ( ( Contains ) ) ;
    public final void rule__Field__ContainmentAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12077:1: ( ( ( Contains ) ) )
            // InternalSolverLanguageParser.g:12078:2: ( ( Contains ) )
            {
            // InternalSolverLanguageParser.g:12078:2: ( ( Contains ) )
            // InternalSolverLanguageParser.g:12079:3: ( Contains )
            {
             before(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); 
            // InternalSolverLanguageParser.g:12080:3: ( Contains )
            // InternalSolverLanguageParser.g:12081:4: Contains
            {
             before(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); 
            match(input,Contains,FOLLOW_2); 
             after(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); 

            }

             after(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__ContainmentAssignment_0_0"


    // $ANTLR start "rule__Field__CrossReferenceAssignment_0_1"
    // InternalSolverLanguageParser.g:12092:1: rule__Field__CrossReferenceAssignment_0_1 : ( ( Refers ) ) ;
    public final void rule__Field__CrossReferenceAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12096:1: ( ( ( Refers ) ) )
            // InternalSolverLanguageParser.g:12097:2: ( ( Refers ) )
            {
            // InternalSolverLanguageParser.g:12097:2: ( ( Refers ) )
            // InternalSolverLanguageParser.g:12098:3: ( Refers )
            {
             before(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); 
            // InternalSolverLanguageParser.g:12099:3: ( Refers )
            // InternalSolverLanguageParser.g:12100:4: Refers
            {
             before(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); 
            match(input,Refers,FOLLOW_2); 
             after(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); 

            }

             after(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__CrossReferenceAssignment_0_1"


    // $ANTLR start "rule__Field__TypeAssignment_1"
    // InternalSolverLanguageParser.g:12111:1: rule__Field__TypeAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__Field__TypeAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12115:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12116:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12116:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12117:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); 
            // InternalSolverLanguageParser.g:12118:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12119:4: ruleQualifiedName
            {
             before(grammarAccess.getFieldAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getFieldAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 

            }

             after(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__TypeAssignment_1"


    // $ANTLR start "rule__Field__MultiplicityAssignment_2"
    // InternalSolverLanguageParser.g:12130:1: rule__Field__MultiplicityAssignment_2 : ( ruleMultiplicity ) ;
    public final void rule__Field__MultiplicityAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12134:1: ( ( ruleMultiplicity ) )
            // InternalSolverLanguageParser.g:12135:2: ( ruleMultiplicity )
            {
            // InternalSolverLanguageParser.g:12135:2: ( ruleMultiplicity )
            // InternalSolverLanguageParser.g:12136:3: ruleMultiplicity
            {
             before(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); 
            pushFollow(FOLLOW_2);
            ruleMultiplicity();

            state._fsp--;

             after(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__MultiplicityAssignment_2"


    // $ANTLR start "rule__Field__NameAssignment_3"
    // InternalSolverLanguageParser.g:12145:1: rule__Field__NameAssignment_3 : ( RULE_ID ) ;
    public final void rule__Field__NameAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12149:1: ( ( RULE_ID ) )
            // InternalSolverLanguageParser.g:12150:2: ( RULE_ID )
            {
            // InternalSolverLanguageParser.g:12150:2: ( RULE_ID )
            // InternalSolverLanguageParser.g:12151:3: RULE_ID
            {
             before(grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); 
            match(input,RULE_ID,FOLLOW_2); 
             after(grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__NameAssignment_3"


    // $ANTLR start "rule__Field__OppositeAssignment_4_1"
    // InternalSolverLanguageParser.g:12160:1: rule__Field__OppositeAssignment_4_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__Field__OppositeAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12164:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12165:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12165:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12166:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); 
            // InternalSolverLanguageParser.g:12167:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12168:4: ruleQualifiedName
            {
             before(grammarAccess.getFieldAccess().getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getFieldAccess().getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1()); 

            }

             after(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Field__OppositeAssignment_4_1"


    // $ANTLR start "rule__ExactMultiplicity__ValueAssignment_1"
    // InternalSolverLanguageParser.g:12179:1: rule__ExactMultiplicity__ValueAssignment_1 : ( ruleUpperMultiplicty ) ;
    public final void rule__ExactMultiplicity__ValueAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12183:1: ( ( ruleUpperMultiplicty ) )
            // InternalSolverLanguageParser.g:12184:2: ( ruleUpperMultiplicty )
            {
            // InternalSolverLanguageParser.g:12184:2: ( ruleUpperMultiplicty )
            // InternalSolverLanguageParser.g:12185:3: ruleUpperMultiplicty
            {
             before(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleUpperMultiplicty();

            state._fsp--;

             after(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactMultiplicity__ValueAssignment_1"


    // $ANTLR start "rule__BoundedMultiplicity__LowerBoundAssignment_1"
    // InternalSolverLanguageParser.g:12194:1: rule__BoundedMultiplicity__LowerBoundAssignment_1 : ( RULE_INT ) ;
    public final void rule__BoundedMultiplicity__LowerBoundAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12198:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12199:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12199:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12200:3: RULE_INT
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__LowerBoundAssignment_1"


    // $ANTLR start "rule__BoundedMultiplicity__UpperBoundAssignment_3"
    // InternalSolverLanguageParser.g:12209:1: rule__BoundedMultiplicity__UpperBoundAssignment_3 : ( ruleUpperMultiplicty ) ;
    public final void rule__BoundedMultiplicity__UpperBoundAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12213:1: ( ( ruleUpperMultiplicty ) )
            // InternalSolverLanguageParser.g:12214:2: ( ruleUpperMultiplicty )
            {
            // InternalSolverLanguageParser.g:12214:2: ( ruleUpperMultiplicty )
            // InternalSolverLanguageParser.g:12215:3: ruleUpperMultiplicty
            {
             before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); 
            pushFollow(FOLLOW_2);
            ruleUpperMultiplicty();

            state._fsp--;

             after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedMultiplicity__UpperBoundAssignment_3"


    // $ANTLR start "rule__EnumDeclaration__NameAssignment_1"
    // InternalSolverLanguageParser.g:12224:1: rule__EnumDeclaration__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__EnumDeclaration__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12228:1: ( ( RULE_ID ) )
            // InternalSolverLanguageParser.g:12229:2: ( RULE_ID )
            {
            // InternalSolverLanguageParser.g:12229:2: ( RULE_ID )
            // InternalSolverLanguageParser.g:12230:3: RULE_ID
            {
             before(grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); 
            match(input,RULE_ID,FOLLOW_2); 
             after(grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__NameAssignment_1"


    // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0"
    // InternalSolverLanguageParser.g:12239:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 : ( ruleEnumLiteral ) ;
    public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12243:1: ( ( ruleEnumLiteral ) )
            // InternalSolverLanguageParser.g:12244:2: ( ruleEnumLiteral )
            {
            // InternalSolverLanguageParser.g:12244:2: ( ruleEnumLiteral )
            // InternalSolverLanguageParser.g:12245:3: ruleEnumLiteral
            {
             before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); 
            pushFollow(FOLLOW_2);
            ruleEnumLiteral();

            state._fsp--;

             after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0"


    // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1"
    // InternalSolverLanguageParser.g:12254:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 : ( ruleEnumLiteral ) ;
    public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12258:1: ( ( ruleEnumLiteral ) )
            // InternalSolverLanguageParser.g:12259:2: ( ruleEnumLiteral )
            {
            // InternalSolverLanguageParser.g:12259:2: ( ruleEnumLiteral )
            // InternalSolverLanguageParser.g:12260:3: ruleEnumLiteral
            {
             before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); 
            pushFollow(FOLLOW_2);
            ruleEnumLiteral();

            state._fsp--;

             after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1"


    // $ANTLR start "rule__EnumLiteral__NameAssignment"
    // InternalSolverLanguageParser.g:12269:1: rule__EnumLiteral__NameAssignment : ( RULE_ID ) ;
    public final void rule__EnumLiteral__NameAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12273:1: ( ( RULE_ID ) )
            // InternalSolverLanguageParser.g:12274:2: ( RULE_ID )
            {
            // InternalSolverLanguageParser.g:12274:2: ( RULE_ID )
            // InternalSolverLanguageParser.g:12275:3: RULE_ID
            {
             before(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); 
            match(input,RULE_ID,FOLLOW_2); 
             after(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumLiteral__NameAssignment"


    // $ANTLR start "rule__ExactScope__TypeAssignment_1"
    // InternalSolverLanguageParser.g:12284:1: rule__ExactScope__TypeAssignment_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__ExactScope__TypeAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12288:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12289:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12289:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12290:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); 
            // InternalSolverLanguageParser.g:12291:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12292:4: ruleQualifiedName
            {
             before(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); 

            }

             after(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__TypeAssignment_1"


    // $ANTLR start "rule__ExactScope__SizeAssignment_3"
    // InternalSolverLanguageParser.g:12303:1: rule__ExactScope__SizeAssignment_3 : ( RULE_INT ) ;
    public final void rule__ExactScope__SizeAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12307:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12308:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12308:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12309:3: RULE_INT
            {
             before(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExactScope__SizeAssignment_3"


    // $ANTLR start "rule__BoundedScope__LowerBoundAssignment_1_0_0_0"
    // InternalSolverLanguageParser.g:12318:1: rule__BoundedScope__LowerBoundAssignment_1_0_0_0 : ( RULE_INT ) ;
    public final void rule__BoundedScope__LowerBoundAssignment_1_0_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12322:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12323:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12323:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12324:3: RULE_INT
            {
             before(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__LowerBoundAssignment_1_0_0_0"


    // $ANTLR start "rule__BoundedScope__TypeAssignment_1_0_1"
    // InternalSolverLanguageParser.g:12333:1: rule__BoundedScope__TypeAssignment_1_0_1 : ( ( ruleQualifiedName ) ) ;
    public final void rule__BoundedScope__TypeAssignment_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12337:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12338:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12338:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12339:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); 
            // InternalSolverLanguageParser.g:12340:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12341:4: ruleQualifiedName
            {
             before(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1()); 

            }

             after(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__TypeAssignment_1_0_1"


    // $ANTLR start "rule__BoundedScope__UpperBoundAssignment_1_0_3"
    // InternalSolverLanguageParser.g:12352:1: rule__BoundedScope__UpperBoundAssignment_1_0_3 : ( RULE_INT ) ;
    public final void rule__BoundedScope__UpperBoundAssignment_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12356:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12357:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12357:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12358:3: RULE_INT
            {
             before(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__UpperBoundAssignment_1_0_3"


    // $ANTLR start "rule__BoundedScope__UpperBoundAssignment_1_1_0"
    // InternalSolverLanguageParser.g:12367:1: rule__BoundedScope__UpperBoundAssignment_1_1_0 : ( RULE_INT ) ;
    public final void rule__BoundedScope__UpperBoundAssignment_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12371:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12372:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12372:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12373:3: RULE_INT
            {
             before(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__UpperBoundAssignment_1_1_0"


    // $ANTLR start "rule__BoundedScope__TypeAssignment_1_1_2"
    // InternalSolverLanguageParser.g:12382:1: rule__BoundedScope__TypeAssignment_1_1_2 : ( ( ruleQualifiedName ) ) ;
    public final void rule__BoundedScope__TypeAssignment_1_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12386:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12387:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12387:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12388:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); 
            // InternalSolverLanguageParser.g:12389:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12390:4: ruleQualifiedName
            {
             before(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1()); 

            }

             after(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__TypeAssignment_1_1_2"


    // $ANTLR start "rule__BoundedScope__LowerBoundAssignment_1_1_3_1"
    // InternalSolverLanguageParser.g:12401:1: rule__BoundedScope__LowerBoundAssignment_1_1_3_1 : ( RULE_INT ) ;
    public final void rule__BoundedScope__LowerBoundAssignment_1_1_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12405:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12406:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12406:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12407:3: RULE_INT
            {
             before(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BoundedScope__LowerBoundAssignment_1_1_3_1"


    // $ANTLR start "rule__LowerBoundedScope__LowerBoundAssignment_1_0_0"
    // InternalSolverLanguageParser.g:12416:1: rule__LowerBoundedScope__LowerBoundAssignment_1_0_0 : ( RULE_INT ) ;
    public final void rule__LowerBoundedScope__LowerBoundAssignment_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12420:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12421:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12421:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12422:3: RULE_INT
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__LowerBoundAssignment_1_0_0"


    // $ANTLR start "rule__LowerBoundedScope__TypeAssignment_1_0_2"
    // InternalSolverLanguageParser.g:12431:1: rule__LowerBoundedScope__TypeAssignment_1_0_2 : ( ( ruleQualifiedName ) ) ;
    public final void rule__LowerBoundedScope__TypeAssignment_1_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12435:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12436:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12436:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12437:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); 
            // InternalSolverLanguageParser.g:12438:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12439:4: ruleQualifiedName
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1()); 

            }

             after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__TypeAssignment_1_0_2"


    // $ANTLR start "rule__LowerBoundedScope__TypeAssignment_1_1_0"
    // InternalSolverLanguageParser.g:12450:1: rule__LowerBoundedScope__TypeAssignment_1_1_0 : ( ( ruleQualifiedName ) ) ;
    public final void rule__LowerBoundedScope__TypeAssignment_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12454:1: ( ( ( ruleQualifiedName ) ) )
            // InternalSolverLanguageParser.g:12455:2: ( ( ruleQualifiedName ) )
            {
            // InternalSolverLanguageParser.g:12455:2: ( ( ruleQualifiedName ) )
            // InternalSolverLanguageParser.g:12456:3: ( ruleQualifiedName )
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); 
            // InternalSolverLanguageParser.g:12457:3: ( ruleQualifiedName )
            // InternalSolverLanguageParser.g:12458:4: ruleQualifiedName
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1()); 
            pushFollow(FOLLOW_2);
            ruleQualifiedName();

            state._fsp--;

             after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1()); 

            }

             after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__TypeAssignment_1_1_0"


    // $ANTLR start "rule__LowerBoundedScope__LowerBoundAssignment_1_1_2"
    // InternalSolverLanguageParser.g:12469:1: rule__LowerBoundedScope__LowerBoundAssignment_1_1_2 : ( RULE_INT ) ;
    public final void rule__LowerBoundedScope__LowerBoundAssignment_1_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12473:1: ( ( RULE_INT ) )
            // InternalSolverLanguageParser.g:12474:2: ( RULE_INT )
            {
            // InternalSolverLanguageParser.g:12474:2: ( RULE_INT )
            // InternalSolverLanguageParser.g:12475:3: RULE_INT
            {
             before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); 
            match(input,RULE_INT,FOLLOW_2); 
             after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LowerBoundedScope__LowerBoundAssignment_1_1_2"


    // $ANTLR start "rule__ObjectiveDeclaration__KindAssignment_0"
    // InternalSolverLanguageParser.g:12484:1: rule__ObjectiveDeclaration__KindAssignment_0 : ( ruleObjectiveKind ) ;
    public final void rule__ObjectiveDeclaration__KindAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12488:1: ( ( ruleObjectiveKind ) )
            // InternalSolverLanguageParser.g:12489:2: ( ruleObjectiveKind )
            {
            // InternalSolverLanguageParser.g:12489:2: ( ruleObjectiveKind )
            // InternalSolverLanguageParser.g:12490:3: ruleObjectiveKind
            {
             before(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); 
            pushFollow(FOLLOW_2);
            ruleObjectiveKind();

            state._fsp--;

             after(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__KindAssignment_0"


    // $ANTLR start "rule__ObjectiveDeclaration__ObjectiveAssignment_1"
    // InternalSolverLanguageParser.g:12499:1: rule__ObjectiveDeclaration__ObjectiveAssignment_1 : ( ruleExpression ) ;
    public final void rule__ObjectiveDeclaration__ObjectiveAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSolverLanguageParser.g:12503:1: ( ( ruleExpression ) )
            // InternalSolverLanguageParser.g:12504:2: ( ruleExpression )
            {
            // InternalSolverLanguageParser.g:12504:2: ( ruleExpression )
            // InternalSolverLanguageParser.g:12505:3: ruleExpression
            {
             before(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); 
            pushFollow(FOLLOW_2);
            ruleExpression();

            state._fsp--;

             after(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ObjectiveDeclaration__ObjectiveAssignment_1"

    // Delegated rules


    protected DFA1 dfa1 = new DFA1(this);
    protected DFA5 dfa5 = new DFA5(this);
    protected DFA9 dfa9 = new DFA9(this);
    protected DFA10 dfa10 = new DFA10(this);
    protected DFA11 dfa11 = new DFA11(this);
    protected DFA18 dfa18 = new DFA18(this);
    static final String dfa_1s = "\35\uffff";
    static final String dfa_2s = "\1\4\1\uffff\3\22\1\5\1\22\1\uffff\1\6\6\uffff\1\22\2\uffff\3\45\1\uffff\4\22\3\45";
    static final String dfa_3s = "\1\113\1\uffff\5\112\1\uffff\1\112\6\uffff\1\112\2\uffff\3\111\1\uffff\4\112\3\111";
    static final String dfa_4s = "\1\uffff\1\1\5\uffff\1\4\1\uffff\1\6\1\7\1\10\1\11\1\12\1\13\1\uffff\1\5\1\2\3\uffff\1\3\7\uffff";
    static final String dfa_5s = "\35\uffff}>";
    static final String[] dfa_6s = {
            "\1\11\1\6\1\15\2\uffff\2\14\1\uffff\1\7\2\uffff\1\1\1\12\1\uffff\1\4\1\uffff\1\15\2\1\1\5\1\1\1\13\1\uffff\1\16\1\10\1\uffff\1\1\1\uffff\2\1\12\uffff\1\1\1\uffff\2\1\2\uffff\1\1\1\uffff\1\1\7\uffff\2\1\5\uffff\2\1\1\3\4\uffff\1\2\1\1",
            "",
            "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20",
            "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20",
            "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20",
            "\1\21\14\uffff\1\24\17\uffff\3\1\1\uffff\6\1\1\uffff\1\1\1\uffff\1\25\1\uffff\4\1\1\uffff\4\1\1\uffff\1\1\3\uffff\1\1\3\uffff\1\21\1\uffff\1\23\3\uffff\1\1\1\22",
            "\1\24\4\uffff\1\21\53\uffff\1\21\1\uffff\1\23\4\uffff\1\22",
            "",
            "\1\15\13\uffff\1\11\1\uffff\1\15\7\uffff\1\15\50\uffff\1\11\4\uffff\1\11",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\30\62\uffff\1\27\4\uffff\1\26",
            "",
            "",
            "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11",
            "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11",
            "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11",
            "",
            "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20",
            "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20",
            "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20",
            "\1\34\62\uffff\1\33\4\uffff\1\32",
            "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11",
            "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11",
            "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11"
    };

    static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
    static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s);
    static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
    static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s);
    static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
    static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s);

    class DFA1 extends DFA {

        public DFA1(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 1;
            this.eot = dfa_1;
            this.eof = dfa_1;
            this.min = dfa_2;
            this.max = dfa_3;
            this.accept = dfa_4;
            this.special = dfa_5;
            this.transition = dfa_6;
        }
        public String getDescription() {
            return "1962:1: rule__Statement__Alternatives : ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPredicateDefintion ) | ( ruleDefaultAssertion ) | ( ruleFunctionDefinition ) | ( ruleAttribute ) | ( ruleExternDeclaration ) | ( ruleScopeDeclaration ) | ( ruleObjectiveDeclaration ) | ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) );";
        }
    }
    static final String dfa_7s = "\24\uffff";
    static final String dfa_8s = "\1\20\1\5\1\uffff\3\22\1\uffff\1\22\3\45\4\22\2\uffff\3\45";
    static final String dfa_9s = "\1\20\1\112\1\uffff\3\112\1\uffff\1\112\3\100\4\112\2\uffff\3\100";
    static final String dfa_10s = "\2\uffff\1\4\3\uffff\1\1\10\uffff\1\2\1\3\3\uffff";
    static final String dfa_11s = "\24\uffff}>";
    static final String[] dfa_12s = {
            "\1\1",
            "\1\6\2\uffff\1\2\11\uffff\1\5\4\uffff\1\6\55\uffff\1\4\4\uffff\1\3",
            "",
            "\1\12\22\uffff\1\7\11\uffff\1\6\25\uffff\1\11\4\uffff\1\10",
            "\1\12\22\uffff\1\7\11\uffff\1\6\25\uffff\1\11\4\uffff\1\10",
            "\1\12\22\uffff\1\7\11\uffff\1\6\25\uffff\1\11\4\uffff\1\10",
            "",
            "\1\15\62\uffff\1\14\4\uffff\1\13",
            "\1\16\11\uffff\1\17\20\uffff\1\20",
            "\1\16\11\uffff\1\17\20\uffff\1\20",
            "\1\16\11\uffff\1\17\20\uffff\1\20",
            "\1\12\22\uffff\1\7\11\uffff\1\6\25\uffff\1\11\4\uffff\1\10",
            "\1\12\22\uffff\1\7\11\uffff\1\6\25\uffff\1\11\4\uffff\1\10",
            "\1\12\22\uffff\1\7\11\uffff\1\6\25\uffff\1\11\4\uffff\1\10",
            "\1\23\62\uffff\1\22\4\uffff\1\21",
            "",
            "",
            "\1\16\11\uffff\1\17\20\uffff\1\20",
            "\1\16\11\uffff\1\17\20\uffff\1\20",
            "\1\16\11\uffff\1\17\20\uffff\1\20"
    };

    static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s);
    static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s);
    static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
    static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s);
    static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
    static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s);

    class DFA5 extends DFA {

        public DFA5(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 5;
            this.eot = dfa_7;
            this.eof = dfa_7;
            this.min = dfa_8;
            this.max = dfa_9;
            this.accept = dfa_10;
            this.special = dfa_11;
            this.transition = dfa_12;
        }
        public String getDescription() {
            return "2106:1: rule__ExternDeclaration__Alternatives : ( ( ruleExternPredicateDeclaration ) | ( ruleExternFunctionDeclaration ) | ( ruleExternAggregationOperatorDeclaration ) | ( ruleExternDatatypeDeclaration ) );";
        }
    }
    static final String dfa_13s = "\13\uffff";
    static final String dfa_14s = "\2\uffff\3\1\3\uffff\3\1";
    static final String dfa_15s = "\1\17\1\uffff\3\32\1\uffff\1\22\1\uffff\3\32";
    static final String dfa_16s = "\1\113\1\uffff\3\111\1\uffff\1\112\1\uffff\3\111";
    static final String dfa_17s = "\1\uffff\1\1\3\uffff\1\3\1\uffff\1\2\3\uffff";
    static final String dfa_18s = "\13\uffff}>";
    static final String[] dfa_19s = {
            "\1\1\2\uffff\1\4\2\uffff\1\5\3\1\5\uffff\1\1\1\uffff\1\1\16\uffff\1\1\15\uffff\1\1\5\uffff\2\1\1\3\4\uffff\1\2\1\1",
            "",
            "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1",
            "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1",
            "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1",
            "",
            "\1\12\62\uffff\1\11\4\uffff\1\10",
            "",
            "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1",
            "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1",
            "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1"
    };

    static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s);
    static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s);
    static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s);
    static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s);
    static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s);
    static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
    static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s);

    class DFA9 extends DFA {

        public DFA9(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 9;
            this.eot = dfa_13;
            this.eof = dfa_14;
            this.min = dfa_15;
            this.max = dfa_16;
            this.accept = dfa_17;
            this.special = dfa_18;
            this.transition = dfa_19;
        }
        public String getDescription() {
            return "2208:1: rule__BracedAggregateExpression__Alternatives : ( ( ruleAtomicExpression ) | ( ruleAggregation ) | ( ruleCount ) );";
        }
    }
    static final String dfa_20s = "\33\uffff";
    static final String dfa_21s = "\2\uffff\3\15\4\uffff\2\15\3\uffff\3\15\1\uffff\3\15\1\uffff\5\15";
    static final String dfa_22s = "\1\17\1\22\3\32\3\uffff\1\22\2\32\1\22\2\uffff\3\32\1\22\3\32\1\22\5\32";
    static final String dfa_23s = "\1\113\1\112\3\111\3\uffff\1\112\2\111\1\112\2\uffff\3\111\1\112\3\111\1\112\5\111";
    static final String dfa_24s = "\5\uffff\1\3\1\4\1\5\4\uffff\1\2\1\1\15\uffff";
    static final String dfa_25s = "\33\uffff}>";
    static final String[] dfa_26s = {
            "\1\6\2\uffff\1\4\3\uffff\3\6\5\uffff\1\6\1\uffff\1\6\16\uffff\1\7\15\uffff\1\5\5\uffff\1\1\1\6\1\3\4\uffff\1\2\1\6",
            "\1\4\62\uffff\1\3\4\uffff\1\2",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\10\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\11\1\12\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\10\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\11\1\12\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\10\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\11\1\12\1\15",
            "",
            "",
            "",
            "\1\20\62\uffff\1\17\4\uffff\1\16",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\uffff\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\6\uffff\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\uffff\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\6\uffff\1\15",
            "\1\24\60\uffff\1\21\1\uffff\1\23\4\uffff\1\22",
            "",
            "",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\10\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\11\1\12\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\10\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\11\1\12\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\10\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\11\1\12\1\15",
            "\1\24\62\uffff\1\23\4\uffff\1\22",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\25\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\26\1\27\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\25\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\26\1\27\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\25\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\26\1\27\1\15",
            "\1\32\62\uffff\1\31\4\uffff\1\30",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\uffff\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\6\uffff\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\uffff\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\6\uffff\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\25\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\26\1\27\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\25\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\26\1\27\1\15",
            "\1\15\2\uffff\1\15\4\uffff\3\15\1\25\6\15\1\uffff\1\15\1\uffff\1\14\5\15\1\13\4\15\1\uffff\1\15\2\uffff\2\15\1\uffff\2\15\4\uffff\1\26\1\27\1\15"
    };

    static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s);
    static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s);
    static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s);
    static final char[] dfa_23 = DFA.unpackEncodedStringToUnsignedChars(dfa_23s);
    static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s);
    static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s);
    static final short[][] dfa_26 = unpackEncodedStringArray(dfa_26s);

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = dfa_20;
            this.eof = dfa_21;
            this.min = dfa_22;
            this.max = dfa_23;
            this.accept = dfa_24;
            this.special = dfa_25;
            this.transition = dfa_26;
        }
        public String getDescription() {
            return "2235:1: rule__AtomicExpression__Alternatives : ( ( ruleReference ) | ( ruleCall ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_4__0 ) ) );";
        }
    }
    static final String dfa_27s = "\16\uffff";
    static final String dfa_28s = "\2\uffff\3\1\4\uffff\1\15\3\1\1\uffff";
    static final String dfa_29s = "\1\17\1\uffff\3\22\1\uffff\1\22\1\61\1\uffff\1\17\3\22\1\uffff";
    static final String dfa_30s = "\1\113\1\uffff\3\112\1\uffff\2\112\1\uffff\1\113\3\112\1\uffff";
    static final String dfa_31s = "\1\uffff\1\1\3\uffff\1\2\2\uffff\1\3\4\uffff\1\4";
    static final String dfa_32s = "\16\uffff}>";
    static final String[] dfa_33s = {
            "\1\1\2\uffff\1\4\2\uffff\4\1\5\uffff\1\1\1\uffff\1\1\15\uffff\2\1\1\uffff\1\5\1\1\1\uffff\1\1\7\uffff\2\1\5\uffff\2\1\1\3\4\uffff\1\2\1\1",
            "",
            "\1\7\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\11\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\10",
            "\1\7\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\11\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\10",
            "\1\7\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\11\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\10",
            "",
            "\1\14\62\uffff\1\13\4\uffff\1\12",
            "\1\15\30\uffff\1\10",
            "",
            "\1\1\2\uffff\1\1\2\uffff\4\1\5\uffff\1\1\1\uffff\1\1\15\uffff\2\1\1\15\1\uffff\1\1\1\15\1\1\7\uffff\2\1\5\uffff\3\1\4\uffff\2\1",
            "\1\7\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\11\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\10",
            "\1\7\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\11\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\10",
            "\1\7\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\11\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\10",
            ""
    };

    static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s);
    static final short[] dfa_28 = DFA.unpackEncodedString(dfa_28s);
    static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s);
    static final char[] dfa_30 = DFA.unpackEncodedStringToUnsignedChars(dfa_30s);
    static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s);
    static final short[] dfa_32 = DFA.unpackEncodedString(dfa_32s);
    static final short[][] dfa_33 = unpackEncodedStringArray(dfa_33s);

    class DFA11 extends DFA {

        public DFA11(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 11;
            this.eot = dfa_27;
            this.eof = dfa_28;
            this.min = dfa_29;
            this.max = dfa_30;
            this.accept = dfa_31;
            this.special = dfa_32;
            this.transition = dfa_33;
        }
        public String getDescription() {
            return "2274:1: rule__Argument__Alternatives : ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedVariableArgument ) | ( ruleTypedStarArgument ) );";
        }
    }
    static final String dfa_34s = "\25\uffff";
    static final String dfa_35s = "\1\31\1\22\1\47\3\45\1\22\1\uffff\1\22\2\uffff\6\45\1\22\3\45";
    static final String dfa_36s = "\1\31\1\113\4\52\1\112\1\uffff\1\112\2\uffff\3\111\3\52\1\112\3\111";
    static final String dfa_37s = "\7\uffff\1\2\1\uffff\1\1\1\3\12\uffff";
    static final String dfa_38s = "\25\uffff}>";
    static final String[] dfa_39s = {
            "\1\1",
            "\1\5\62\uffff\1\4\4\uffff\1\3\1\2",
            "\1\6\2\uffff\1\7",
            "\1\10\1\uffff\1\7\1\11\1\uffff\1\12",
            "\1\10\1\uffff\1\7\1\11\1\uffff\1\12",
            "\1\10\1\uffff\1\7\1\11\1\uffff\1\12",
            "\1\15\62\uffff\1\14\4\uffff\1\13",
            "",
            "\1\20\62\uffff\1\17\4\uffff\1\16",
            "",
            "",
            "\1\21\1\uffff\1\7\41\uffff\1\12",
            "\1\21\1\uffff\1\7\41\uffff\1\12",
            "\1\21\1\uffff\1\7\41\uffff\1\12",
            "\1\10\1\uffff\1\7\1\11\1\uffff\1\12",
            "\1\10\1\uffff\1\7\1\11\1\uffff\1\12",
            "\1\10\1\uffff\1\7\1\11\1\uffff\1\12",
            "\1\24\62\uffff\1\23\4\uffff\1\22",
            "\1\21\1\uffff\1\7\41\uffff\1\12",
            "\1\21\1\uffff\1\7\41\uffff\1\12",
            "\1\21\1\uffff\1\7\41\uffff\1\12"
    };

    static final short[] dfa_34 = DFA.unpackEncodedString(dfa_34s);
    static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s);
    static final char[] dfa_36 = DFA.unpackEncodedStringToUnsignedChars(dfa_36s);
    static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s);
    static final short[] dfa_38 = DFA.unpackEncodedString(dfa_38s);
    static final short[][] dfa_39 = unpackEncodedStringArray(dfa_39s);

    class DFA18 extends DFA {

        public DFA18(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 18;
            this.eot = dfa_34;
            this.eof = dfa_34;
            this.min = dfa_35;
            this.max = dfa_36;
            this.accept = dfa_37;
            this.special = dfa_38;
            this.transition = dfa_39;
        }
        public String getDescription() {
            return "2463:1: rule__ScopeDeclaration__Alternatives : ( ( ruleExactScope ) | ( ruleBoundedScope ) | ( ruleLowerBoundedScope ) );";
        }
    }
 

    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[]{0x3014D0035BE79670L,0x0000000000000C38L});
    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000020002L});
    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x3014D0035BE59672L,0x0000000000000C38L});
    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000428L});
    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0080005000000000L});
    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x3014D00341E48000L,0x0000000000000C38L});
    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0080000000000000L,0x0000000000000200L});
    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000800020L});
    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0008200000000000L});
    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0100000800000000L});
    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0100000000000002L});
    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0008000000000000L});
    public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0A00258400000000L});
    public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0014000000000000L});
    public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0014000000000002L});
    public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0042000000000000L});
    public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0042000000000002L});
    public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x2000800141E48000L,0x0000000000000C38L});
    public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x3017D00341E48000L,0x0000000000000C38L});
    public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x3016D00341E48000L,0x0000000000000C38L});
    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0020000000000002L});
    public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000002000L,0x0000000000000201L});
    public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x00000000000C0080L,0x000000000000042CL});
    public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x00000000000C0082L,0x0000000000000428L});
    public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x00000000000C0080L,0x0000000000000428L});
    public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0100000000000800L});
    public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000201L});
    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000404L});
    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0008000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0008000000000002L,0x0000000000000400L});
    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000010000000000L});
    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000C28L});
    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000002000000002L});
    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000800022L});
    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000010000042L});

}