1 files changed, 10617 insertions, 0 deletions

diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components.ide/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/ide/contentassist/antlr/internal/InternalCftLanguageParser.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components.ide/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/ide/contentassist/antlr/internal/InternalCftLanguageParser.java
new file mode 100644
index 00000000..a12d9fd8
--- /dev/null
+++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components.ide/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/ide/contentassist/antlr/internal/InternalCftLanguageParser.java
@@ -0,0 +1,10617 @@
+package hu.bme.mit.inf.dslreasoner.faulttree.components.ide.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
+import hu.bme.mit.inf.dslreasoner.faulttree.components.services.CftLanguageGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalCftLanguageParser extends AbstractInternalContentAssistParser {
+    public static final String[] tokenNames = new String[] {
+        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_DOULBE", "RULE_INT", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "':='", "'package'", "';'", "'import'", "'cft'", "'{'", "'}'", "'in'", "'out'", "'lambda'", "'='", "'and'", "'or'", "'transformation'", "'mapping'", "'('", "')'", "','", "'lookup'", "'as'", "'.'", "'=>'", "'*'", "'[]'", "'toplevel'", "'+='"
+    };
+    public static final int RULE_STRING=7;
+    public static final int RULE_SL_COMMENT=9;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__37=37;
+    public static final int T__16=16;
+    public static final int T__17=17;
+    public static final int T__18=18;
+    public static final int T__33=33;
+    public static final int T__12=12;
+    public static final int T__34=34;
+    public static final int T__13=13;
+    public static final int T__35=35;
+    public static final int T__14=14;
+    public static final int T__36=36;
+    public static final int EOF=-1;
+    public static final int T__30=30;
+    public static final int T__31=31;
+    public static final int T__32=32;
+    public static final int RULE_ID=4;
+    public static final int RULE_WS=10;
+    public static final int RULE_DOULBE=5;
+    public static final int RULE_ANY_OTHER=11;
+    public static final int T__26=26;
+    public static final int T__27=27;
+    public static final int T__28=28;
+    public static final int RULE_INT=6;
+    public static final int T__29=29;
+    public static final int T__22=22;
+    public static final int RULE_ML_COMMENT=8;
+    public static final int T__23=23;
+    public static final int T__24=24;
+    public static final int T__25=25;
+    public static final int T__20=20;
+    public static final int T__21=21;
+
+    // delegates
+    // delegators
+
+
+        public InternalCftLanguageParser(TokenStream input) {
+            this(input, new RecognizerSharedState());
+        }
+        public InternalCftLanguageParser(TokenStream input, RecognizerSharedState state) {
+            super(input, state);
+             
+        }
+        
+
+    public String[] getTokenNames() { return InternalCftLanguageParser.tokenNames; }
+    public String getGrammarFileName() { return "InternalCftLanguage.g"; }
+
+
+        private CftLanguageGrammarAccess grammarAccess;
+
+        public void setGrammarAccess(CftLanguageGrammarAccess grammarAccess) {
+                this.grammarAccess = grammarAccess;
+        }
+
+        @Override
+        protected Grammar getGrammar() {
+                return grammarAccess.getGrammar();
+        }
+
+        @Override
+        protected String getValueForTokenName(String tokenName) {
+                return tokenName;
+        }
+
+
+
+    // $ANTLR start "entryRuleCftModel"
+    // InternalCftLanguage.g:53:1: entryRuleCftModel : ruleCftModel EOF ;
+    public final void entryRuleCftModel() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:54:1: ( ruleCftModel EOF )
+            // InternalCftLanguage.g:55:1: ruleCftModel EOF
+            {
+             before(grammarAccess.getCftModelRule()); 
+            pushFollow(FOLLOW_1);
+            ruleCftModel();
+
+            state._fsp--;
+
+             after(grammarAccess.getCftModelRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleCftModel"
+
+
+    // $ANTLR start "ruleCftModel"
+    // InternalCftLanguage.g:62:1: ruleCftModel : ( ( rule__CftModel__Group__0 ) ) ;
+    public final void ruleCftModel() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:66:2: ( ( ( rule__CftModel__Group__0 ) ) )
+            // InternalCftLanguage.g:67:2: ( ( rule__CftModel__Group__0 ) )
+            {
+            // InternalCftLanguage.g:67:2: ( ( rule__CftModel__Group__0 ) )
+            // InternalCftLanguage.g:68:3: ( rule__CftModel__Group__0 )
+            {
+             before(grammarAccess.getCftModelAccess().getGroup()); 
+            // InternalCftLanguage.g:69:3: ( rule__CftModel__Group__0 )
+            // InternalCftLanguage.g:69:4: rule__CftModel__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__CftModel__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getCftModelAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleCftModel"
+
+
+    // $ANTLR start "entryRuleImportDeclaration"
+    // InternalCftLanguage.g:78:1: entryRuleImportDeclaration : ruleImportDeclaration EOF ;
+    public final void entryRuleImportDeclaration() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:79:1: ( ruleImportDeclaration EOF )
+            // InternalCftLanguage.g:80:1: ruleImportDeclaration EOF
+            {
+             before(grammarAccess.getImportDeclarationRule()); 
+            pushFollow(FOLLOW_1);
+            ruleImportDeclaration();
+
+            state._fsp--;
+
+             after(grammarAccess.getImportDeclarationRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleImportDeclaration"
+
+
+    // $ANTLR start "ruleImportDeclaration"
+    // InternalCftLanguage.g:87:1: ruleImportDeclaration : ( ( rule__ImportDeclaration__Group__0 ) ) ;
+    public final void ruleImportDeclaration() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:91:2: ( ( ( rule__ImportDeclaration__Group__0 ) ) )
+            // InternalCftLanguage.g:92:2: ( ( rule__ImportDeclaration__Group__0 ) )
+            {
+            // InternalCftLanguage.g:92:2: ( ( rule__ImportDeclaration__Group__0 ) )
+            // InternalCftLanguage.g:93:3: ( rule__ImportDeclaration__Group__0 )
+            {
+             before(grammarAccess.getImportDeclarationAccess().getGroup()); 
+            // InternalCftLanguage.g:94:3: ( rule__ImportDeclaration__Group__0 )
+            // InternalCftLanguage.g:94:4: rule__ImportDeclaration__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__ImportDeclaration__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getImportDeclarationAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleImportDeclaration"
+
+
+    // $ANTLR start "entryRuleComponentDefinition"
+    // InternalCftLanguage.g:103:1: entryRuleComponentDefinition : ruleComponentDefinition EOF ;
+    public final void entryRuleComponentDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:104:1: ( ruleComponentDefinition EOF )
+            // InternalCftLanguage.g:105:1: ruleComponentDefinition EOF
+            {
+             before(grammarAccess.getComponentDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleComponentDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getComponentDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleComponentDefinition"
+
+
+    // $ANTLR start "ruleComponentDefinition"
+    // InternalCftLanguage.g:112:1: ruleComponentDefinition : ( ( rule__ComponentDefinition__Group__0 ) ) ;
+    public final void ruleComponentDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:116:2: ( ( ( rule__ComponentDefinition__Group__0 ) ) )
+            // InternalCftLanguage.g:117:2: ( ( rule__ComponentDefinition__Group__0 ) )
+            {
+            // InternalCftLanguage.g:117:2: ( ( rule__ComponentDefinition__Group__0 ) )
+            // InternalCftLanguage.g:118:3: ( rule__ComponentDefinition__Group__0 )
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getGroup()); 
+            // InternalCftLanguage.g:119:3: ( rule__ComponentDefinition__Group__0 )
+            // InternalCftLanguage.g:119:4: rule__ComponentDefinition__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getComponentDefinitionAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleComponentDefinition"
+
+
+    // $ANTLR start "entryRuleInputEvent"
+    // InternalCftLanguage.g:128:1: entryRuleInputEvent : ruleInputEvent EOF ;
+    public final void entryRuleInputEvent() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:129:1: ( ruleInputEvent EOF )
+            // InternalCftLanguage.g:130:1: ruleInputEvent EOF
+            {
+             before(grammarAccess.getInputEventRule()); 
+            pushFollow(FOLLOW_1);
+            ruleInputEvent();
+
+            state._fsp--;
+
+             after(grammarAccess.getInputEventRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleInputEvent"
+
+
+    // $ANTLR start "ruleInputEvent"
+    // InternalCftLanguage.g:137:1: ruleInputEvent : ( ( rule__InputEvent__Group__0 ) ) ;
+    public final void ruleInputEvent() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:141:2: ( ( ( rule__InputEvent__Group__0 ) ) )
+            // InternalCftLanguage.g:142:2: ( ( rule__InputEvent__Group__0 ) )
+            {
+            // InternalCftLanguage.g:142:2: ( ( rule__InputEvent__Group__0 ) )
+            // InternalCftLanguage.g:143:3: ( rule__InputEvent__Group__0 )
+            {
+             before(grammarAccess.getInputEventAccess().getGroup()); 
+            // InternalCftLanguage.g:144:3: ( rule__InputEvent__Group__0 )
+            // InternalCftLanguage.g:144:4: rule__InputEvent__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__InputEvent__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getInputEventAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleInputEvent"
+
+
+    // $ANTLR start "entryRuleEventDefinition"
+    // InternalCftLanguage.g:153:1: entryRuleEventDefinition : ruleEventDefinition EOF ;
+    public final void entryRuleEventDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:154:1: ( ruleEventDefinition EOF )
+            // InternalCftLanguage.g:155:1: ruleEventDefinition EOF
+            {
+             before(grammarAccess.getEventDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleEventDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getEventDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleEventDefinition"
+
+
+    // $ANTLR start "ruleEventDefinition"
+    // InternalCftLanguage.g:162:1: ruleEventDefinition : ( ( rule__EventDefinition__Alternatives ) ) ;
+    public final void ruleEventDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:166:2: ( ( ( rule__EventDefinition__Alternatives ) ) )
+            // InternalCftLanguage.g:167:2: ( ( rule__EventDefinition__Alternatives ) )
+            {
+            // InternalCftLanguage.g:167:2: ( ( rule__EventDefinition__Alternatives ) )
+            // InternalCftLanguage.g:168:3: ( rule__EventDefinition__Alternatives )
+            {
+             before(grammarAccess.getEventDefinitionAccess().getAlternatives()); 
+            // InternalCftLanguage.g:169:3: ( rule__EventDefinition__Alternatives )
+            // InternalCftLanguage.g:169:4: rule__EventDefinition__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__EventDefinition__Alternatives();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getEventDefinitionAccess().getAlternatives()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleEventDefinition"
+
+
+    // $ANTLR start "entryRuleBasicEventDefinition"
+    // InternalCftLanguage.g:178:1: entryRuleBasicEventDefinition : ruleBasicEventDefinition EOF ;
+    public final void entryRuleBasicEventDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:179:1: ( ruleBasicEventDefinition EOF )
+            // InternalCftLanguage.g:180:1: ruleBasicEventDefinition EOF
+            {
+             before(grammarAccess.getBasicEventDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleBasicEventDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getBasicEventDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleBasicEventDefinition"
+
+
+    // $ANTLR start "ruleBasicEventDefinition"
+    // InternalCftLanguage.g:187:1: ruleBasicEventDefinition : ( ( rule__BasicEventDefinition__Group__0 ) ) ;
+    public final void ruleBasicEventDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:191:2: ( ( ( rule__BasicEventDefinition__Group__0 ) ) )
+            // InternalCftLanguage.g:192:2: ( ( rule__BasicEventDefinition__Group__0 ) )
+            {
+            // InternalCftLanguage.g:192:2: ( ( rule__BasicEventDefinition__Group__0 ) )
+            // InternalCftLanguage.g:193:3: ( rule__BasicEventDefinition__Group__0 )
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getGroup()); 
+            // InternalCftLanguage.g:194:3: ( rule__BasicEventDefinition__Group__0 )
+            // InternalCftLanguage.g:194:4: rule__BasicEventDefinition__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getBasicEventDefinitionAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleBasicEventDefinition"
+
+
+    // $ANTLR start "entryRuleGateDefinition"
+    // InternalCftLanguage.g:203:1: entryRuleGateDefinition : ruleGateDefinition EOF ;
+    public final void entryRuleGateDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:204:1: ( ruleGateDefinition EOF )
+            // InternalCftLanguage.g:205:1: ruleGateDefinition EOF
+            {
+             before(grammarAccess.getGateDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleGateDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getGateDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleGateDefinition"
+
+
+    // $ANTLR start "ruleGateDefinition"
+    // InternalCftLanguage.g:212:1: ruleGateDefinition : ( ( rule__GateDefinition__Alternatives ) ) ;
+    public final void ruleGateDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:216:2: ( ( ( rule__GateDefinition__Alternatives ) ) )
+            // InternalCftLanguage.g:217:2: ( ( rule__GateDefinition__Alternatives ) )
+            {
+            // InternalCftLanguage.g:217:2: ( ( rule__GateDefinition__Alternatives ) )
+            // InternalCftLanguage.g:218:3: ( rule__GateDefinition__Alternatives )
+            {
+             before(grammarAccess.getGateDefinitionAccess().getAlternatives()); 
+            // InternalCftLanguage.g:219:3: ( rule__GateDefinition__Alternatives )
+            // InternalCftLanguage.g:219:4: rule__GateDefinition__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__GateDefinition__Alternatives();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getGateDefinitionAccess().getAlternatives()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleGateDefinition"
+
+
+    // $ANTLR start "entryRuleAndGate"
+    // InternalCftLanguage.g:228:1: entryRuleAndGate : ruleAndGate EOF ;
+    public final void entryRuleAndGate() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:229:1: ( ruleAndGate EOF )
+            // InternalCftLanguage.g:230:1: ruleAndGate EOF
+            {
+             before(grammarAccess.getAndGateRule()); 
+            pushFollow(FOLLOW_1);
+            ruleAndGate();
+
+            state._fsp--;
+
+             after(grammarAccess.getAndGateRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleAndGate"
+
+
+    // $ANTLR start "ruleAndGate"
+    // InternalCftLanguage.g:237:1: ruleAndGate : ( ( rule__AndGate__Group__0 ) ) ;
+    public final void ruleAndGate() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:241:2: ( ( ( rule__AndGate__Group__0 ) ) )
+            // InternalCftLanguage.g:242:2: ( ( rule__AndGate__Group__0 ) )
+            {
+            // InternalCftLanguage.g:242:2: ( ( rule__AndGate__Group__0 ) )
+            // InternalCftLanguage.g:243:3: ( rule__AndGate__Group__0 )
+            {
+             before(grammarAccess.getAndGateAccess().getGroup()); 
+            // InternalCftLanguage.g:244:3: ( rule__AndGate__Group__0 )
+            // InternalCftLanguage.g:244:4: rule__AndGate__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__AndGate__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getAndGateAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleAndGate"
+
+
+    // $ANTLR start "entryRuleOrGate"
+    // InternalCftLanguage.g:253:1: entryRuleOrGate : ruleOrGate EOF ;
+    public final void entryRuleOrGate() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:254:1: ( ruleOrGate EOF )
+            // InternalCftLanguage.g:255:1: ruleOrGate EOF
+            {
+             before(grammarAccess.getOrGateRule()); 
+            pushFollow(FOLLOW_1);
+            ruleOrGate();
+
+            state._fsp--;
+
+             after(grammarAccess.getOrGateRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOrGate"
+
+
+    // $ANTLR start "ruleOrGate"
+    // InternalCftLanguage.g:262:1: ruleOrGate : ( ( rule__OrGate__Group__0 ) ) ;
+    public final void ruleOrGate() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:266:2: ( ( ( rule__OrGate__Group__0 ) ) )
+            // InternalCftLanguage.g:267:2: ( ( rule__OrGate__Group__0 ) )
+            {
+            // InternalCftLanguage.g:267:2: ( ( rule__OrGate__Group__0 ) )
+            // InternalCftLanguage.g:268:3: ( rule__OrGate__Group__0 )
+            {
+             before(grammarAccess.getOrGateAccess().getGroup()); 
+            // InternalCftLanguage.g:269:3: ( rule__OrGate__Group__0 )
+            // InternalCftLanguage.g:269:4: rule__OrGate__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__OrGate__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getOrGateAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOrGate"
+
+
+    // $ANTLR start "entryRuleTransformationDefinition"
+    // InternalCftLanguage.g:278:1: entryRuleTransformationDefinition : ruleTransformationDefinition EOF ;
+    public final void entryRuleTransformationDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:279:1: ( ruleTransformationDefinition EOF )
+            // InternalCftLanguage.g:280:1: ruleTransformationDefinition EOF
+            {
+             before(grammarAccess.getTransformationDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleTransformationDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getTransformationDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleTransformationDefinition"
+
+
+    // $ANTLR start "ruleTransformationDefinition"
+    // InternalCftLanguage.g:287:1: ruleTransformationDefinition : ( ( rule__TransformationDefinition__Group__0 ) ) ;
+    public final void ruleTransformationDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:291:2: ( ( ( rule__TransformationDefinition__Group__0 ) ) )
+            // InternalCftLanguage.g:292:2: ( ( rule__TransformationDefinition__Group__0 ) )
+            {
+            // InternalCftLanguage.g:292:2: ( ( rule__TransformationDefinition__Group__0 ) )
+            // InternalCftLanguage.g:293:3: ( rule__TransformationDefinition__Group__0 )
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getGroup()); 
+            // InternalCftLanguage.g:294:3: ( rule__TransformationDefinition__Group__0 )
+            // InternalCftLanguage.g:294:4: rule__TransformationDefinition__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getTransformationDefinitionAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleTransformationDefinition"
+
+
+    // $ANTLR start "entryRuleMappingDefinition"
+    // InternalCftLanguage.g:303:1: entryRuleMappingDefinition : ruleMappingDefinition EOF ;
+    public final void entryRuleMappingDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:304:1: ( ruleMappingDefinition EOF )
+            // InternalCftLanguage.g:305:1: ruleMappingDefinition EOF
+            {
+             before(grammarAccess.getMappingDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleMappingDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleMappingDefinition"
+
+
+    // $ANTLR start "ruleMappingDefinition"
+    // InternalCftLanguage.g:312:1: ruleMappingDefinition : ( ( rule__MappingDefinition__Group__0 ) ) ;
+    public final void ruleMappingDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:316:2: ( ( ( rule__MappingDefinition__Group__0 ) ) )
+            // InternalCftLanguage.g:317:2: ( ( rule__MappingDefinition__Group__0 ) )
+            {
+            // InternalCftLanguage.g:317:2: ( ( rule__MappingDefinition__Group__0 ) )
+            // InternalCftLanguage.g:318:3: ( rule__MappingDefinition__Group__0 )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getGroup()); 
+            // InternalCftLanguage.g:319:3: ( rule__MappingDefinition__Group__0 )
+            // InternalCftLanguage.g:319:4: rule__MappingDefinition__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleMappingDefinition"
+
+
+    // $ANTLR start "entryRuleMappingParameter"
+    // InternalCftLanguage.g:328:1: entryRuleMappingParameter : ruleMappingParameter EOF ;
+    public final void entryRuleMappingParameter() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:329:1: ( ruleMappingParameter EOF )
+            // InternalCftLanguage.g:330:1: ruleMappingParameter EOF
+            {
+             before(grammarAccess.getMappingParameterRule()); 
+            pushFollow(FOLLOW_1);
+            ruleMappingParameter();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingParameterRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleMappingParameter"
+
+
+    // $ANTLR start "ruleMappingParameter"
+    // InternalCftLanguage.g:337:1: ruleMappingParameter : ( ( rule__MappingParameter__NameAssignment ) ) ;
+    public final void ruleMappingParameter() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:341:2: ( ( ( rule__MappingParameter__NameAssignment ) ) )
+            // InternalCftLanguage.g:342:2: ( ( rule__MappingParameter__NameAssignment ) )
+            {
+            // InternalCftLanguage.g:342:2: ( ( rule__MappingParameter__NameAssignment ) )
+            // InternalCftLanguage.g:343:3: ( rule__MappingParameter__NameAssignment )
+            {
+             before(grammarAccess.getMappingParameterAccess().getNameAssignment()); 
+            // InternalCftLanguage.g:344:3: ( rule__MappingParameter__NameAssignment )
+            // InternalCftLanguage.g:344:4: rule__MappingParameter__NameAssignment
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingParameter__NameAssignment();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMappingParameterAccess().getNameAssignment()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleMappingParameter"
+
+
+    // $ANTLR start "entryRuleLookupDefinition"
+    // InternalCftLanguage.g:353:1: entryRuleLookupDefinition : ruleLookupDefinition EOF ;
+    public final void entryRuleLookupDefinition() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:354:1: ( ruleLookupDefinition EOF )
+            // InternalCftLanguage.g:355:1: ruleLookupDefinition EOF
+            {
+             before(grammarAccess.getLookupDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            ruleLookupDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getLookupDefinitionRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleLookupDefinition"
+
+
+    // $ANTLR start "ruleLookupDefinition"
+    // InternalCftLanguage.g:362:1: ruleLookupDefinition : ( ( rule__LookupDefinition__Group__0 ) ) ;
+    public final void ruleLookupDefinition() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:366:2: ( ( ( rule__LookupDefinition__Group__0 ) ) )
+            // InternalCftLanguage.g:367:2: ( ( rule__LookupDefinition__Group__0 ) )
+            {
+            // InternalCftLanguage.g:367:2: ( ( rule__LookupDefinition__Group__0 ) )
+            // InternalCftLanguage.g:368:3: ( rule__LookupDefinition__Group__0 )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getGroup()); 
+            // InternalCftLanguage.g:369:3: ( rule__LookupDefinition__Group__0 )
+            // InternalCftLanguage.g:369:4: rule__LookupDefinition__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleLookupDefinition"
+
+
+    // $ANTLR start "entryRuleAssignment"
+    // InternalCftLanguage.g:378:1: entryRuleAssignment : ruleAssignment EOF ;
+    public final void entryRuleAssignment() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:379:1: ( ruleAssignment EOF )
+            // InternalCftLanguage.g:380:1: ruleAssignment EOF
+            {
+             before(grammarAccess.getAssignmentRule()); 
+            pushFollow(FOLLOW_1);
+            ruleAssignment();
+
+            state._fsp--;
+
+             after(grammarAccess.getAssignmentRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleAssignment"
+
+
+    // $ANTLR start "ruleAssignment"
+    // InternalCftLanguage.g:387:1: ruleAssignment : ( ( rule__Assignment__Group__0 ) ) ;
+    public final void ruleAssignment() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:391:2: ( ( ( rule__Assignment__Group__0 ) ) )
+            // InternalCftLanguage.g:392:2: ( ( rule__Assignment__Group__0 ) )
+            {
+            // InternalCftLanguage.g:392:2: ( ( rule__Assignment__Group__0 ) )
+            // InternalCftLanguage.g:393:3: ( rule__Assignment__Group__0 )
+            {
+             before(grammarAccess.getAssignmentAccess().getGroup()); 
+            // InternalCftLanguage.g:394:3: ( rule__Assignment__Group__0 )
+            // InternalCftLanguage.g:394:4: rule__Assignment__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__Assignment__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getAssignmentAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleAssignment"
+
+
+    // $ANTLR start "entryRuleEventReference"
+    // InternalCftLanguage.g:403:1: entryRuleEventReference : ruleEventReference EOF ;
+    public final void entryRuleEventReference() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:404:1: ( ruleEventReference EOF )
+            // InternalCftLanguage.g:405:1: ruleEventReference EOF
+            {
+             before(grammarAccess.getEventReferenceRule()); 
+            pushFollow(FOLLOW_1);
+            ruleEventReference();
+
+            state._fsp--;
+
+             after(grammarAccess.getEventReferenceRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleEventReference"
+
+
+    // $ANTLR start "ruleEventReference"
+    // InternalCftLanguage.g:412:1: ruleEventReference : ( ( rule__EventReference__Group__0 ) ) ;
+    public final void ruleEventReference() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:416:2: ( ( ( rule__EventReference__Group__0 ) ) )
+            // InternalCftLanguage.g:417:2: ( ( rule__EventReference__Group__0 ) )
+            {
+            // InternalCftLanguage.g:417:2: ( ( rule__EventReference__Group__0 ) )
+            // InternalCftLanguage.g:418:3: ( rule__EventReference__Group__0 )
+            {
+             before(grammarAccess.getEventReferenceAccess().getGroup()); 
+            // InternalCftLanguage.g:419:3: ( rule__EventReference__Group__0 )
+            // InternalCftLanguage.g:419:4: rule__EventReference__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__EventReference__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getEventReferenceAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleEventReference"
+
+
+    // $ANTLR start "entryRuleComponentInstance"
+    // InternalCftLanguage.g:428:1: entryRuleComponentInstance : ruleComponentInstance EOF ;
+    public final void entryRuleComponentInstance() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:429:1: ( ruleComponentInstance EOF )
+            // InternalCftLanguage.g:430:1: ruleComponentInstance EOF
+            {
+             before(grammarAccess.getComponentInstanceRule()); 
+            pushFollow(FOLLOW_1);
+            ruleComponentInstance();
+
+            state._fsp--;
+
+             after(grammarAccess.getComponentInstanceRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleComponentInstance"
+
+
+    // $ANTLR start "ruleComponentInstance"
+    // InternalCftLanguage.g:437:1: ruleComponentInstance : ( ( rule__ComponentInstance__Group__0 ) ) ;
+    public final void ruleComponentInstance() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:441:2: ( ( ( rule__ComponentInstance__Group__0 ) ) )
+            // InternalCftLanguage.g:442:2: ( ( rule__ComponentInstance__Group__0 ) )
+            {
+            // InternalCftLanguage.g:442:2: ( ( rule__ComponentInstance__Group__0 ) )
+            // InternalCftLanguage.g:443:3: ( rule__ComponentInstance__Group__0 )
+            {
+             before(grammarAccess.getComponentInstanceAccess().getGroup()); 
+            // InternalCftLanguage.g:444:3: ( rule__ComponentInstance__Group__0 )
+            // InternalCftLanguage.g:444:4: rule__ComponentInstance__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentInstance__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getComponentInstanceAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleComponentInstance"
+
+
+    // $ANTLR start "entryRuleQualifiedName"
+    // InternalCftLanguage.g:453:1: entryRuleQualifiedName : ruleQualifiedName EOF ;
+    public final void entryRuleQualifiedName() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:454:1: ( ruleQualifiedName EOF )
+            // InternalCftLanguage.g:455: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 {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleQualifiedName"
+
+
+    // $ANTLR start "ruleQualifiedName"
+    // InternalCftLanguage.g:462:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ;
+    public final void ruleQualifiedName() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:466:2: ( ( ( rule__QualifiedName__Group__0 ) ) )
+            // InternalCftLanguage.g:467:2: ( ( rule__QualifiedName__Group__0 ) )
+            {
+            // InternalCftLanguage.g:467:2: ( ( rule__QualifiedName__Group__0 ) )
+            // InternalCftLanguage.g:468:3: ( rule__QualifiedName__Group__0 )
+            {
+             before(grammarAccess.getQualifiedNameAccess().getGroup()); 
+            // InternalCftLanguage.g:469:3: ( rule__QualifiedName__Group__0 )
+            // InternalCftLanguage.g:469: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);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleQualifiedName"
+
+
+    // $ANTLR start "entryRuleQualifiedNameWithWildcard"
+    // InternalCftLanguage.g:478:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ;
+    public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException {
+        try {
+            // InternalCftLanguage.g:479:1: ( ruleQualifiedNameWithWildcard EOF )
+            // InternalCftLanguage.g:480:1: ruleQualifiedNameWithWildcard EOF
+            {
+             before(grammarAccess.getQualifiedNameWithWildcardRule()); 
+            pushFollow(FOLLOW_1);
+            ruleQualifiedNameWithWildcard();
+
+            state._fsp--;
+
+             after(grammarAccess.getQualifiedNameWithWildcardRule()); 
+            match(input,EOF,FOLLOW_2); 
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleQualifiedNameWithWildcard"
+
+
+    // $ANTLR start "ruleQualifiedNameWithWildcard"
+    // InternalCftLanguage.g:487:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ;
+    public final void ruleQualifiedNameWithWildcard() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:491:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) )
+            // InternalCftLanguage.g:492:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) )
+            {
+            // InternalCftLanguage.g:492:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) )
+            // InternalCftLanguage.g:493:3: ( rule__QualifiedNameWithWildcard__Group__0 )
+            {
+             before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); 
+            // InternalCftLanguage.g:494:3: ( rule__QualifiedNameWithWildcard__Group__0 )
+            // InternalCftLanguage.g:494:4: rule__QualifiedNameWithWildcard__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleQualifiedNameWithWildcard"
+
+
+    // $ANTLR start "rule__CftModel__Alternatives_4"
+    // InternalCftLanguage.g:502:1: rule__CftModel__Alternatives_4 : ( ( ( rule__CftModel__ComponentDefinitionsAssignment_4_0 ) ) | ( ( rule__CftModel__TransformationDefinitionsAssignment_4_1 ) ) );
+    public final void rule__CftModel__Alternatives_4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:506:1: ( ( ( rule__CftModel__ComponentDefinitionsAssignment_4_0 ) ) | ( ( rule__CftModel__TransformationDefinitionsAssignment_4_1 ) ) )
+            int alt1=2;
+            int LA1_0 = input.LA(1);
+
+            if ( (LA1_0==16) ) {
+                alt1=1;
+            }
+            else if ( (LA1_0==25) ) {
+                alt1=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 1, 0, input);
+
+                throw nvae;
+            }
+            switch (alt1) {
+                case 1 :
+                    // InternalCftLanguage.g:507:2: ( ( rule__CftModel__ComponentDefinitionsAssignment_4_0 ) )
+                    {
+                    // InternalCftLanguage.g:507:2: ( ( rule__CftModel__ComponentDefinitionsAssignment_4_0 ) )
+                    // InternalCftLanguage.g:508:3: ( rule__CftModel__ComponentDefinitionsAssignment_4_0 )
+                    {
+                     before(grammarAccess.getCftModelAccess().getComponentDefinitionsAssignment_4_0()); 
+                    // InternalCftLanguage.g:509:3: ( rule__CftModel__ComponentDefinitionsAssignment_4_0 )
+                    // InternalCftLanguage.g:509:4: rule__CftModel__ComponentDefinitionsAssignment_4_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__CftModel__ComponentDefinitionsAssignment_4_0();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getCftModelAccess().getComponentDefinitionsAssignment_4_0()); 
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalCftLanguage.g:513:2: ( ( rule__CftModel__TransformationDefinitionsAssignment_4_1 ) )
+                    {
+                    // InternalCftLanguage.g:513:2: ( ( rule__CftModel__TransformationDefinitionsAssignment_4_1 ) )
+                    // InternalCftLanguage.g:514:3: ( rule__CftModel__TransformationDefinitionsAssignment_4_1 )
+                    {
+                     before(grammarAccess.getCftModelAccess().getTransformationDefinitionsAssignment_4_1()); 
+                    // InternalCftLanguage.g:515:3: ( rule__CftModel__TransformationDefinitionsAssignment_4_1 )
+                    // InternalCftLanguage.g:515:4: rule__CftModel__TransformationDefinitionsAssignment_4_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__CftModel__TransformationDefinitionsAssignment_4_1();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getCftModelAccess().getTransformationDefinitionsAssignment_4_1()); 
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Alternatives_4"
+
+
+    // $ANTLR start "rule__EventDefinition__Alternatives"
+    // InternalCftLanguage.g:523:1: rule__EventDefinition__Alternatives : ( ( ruleBasicEventDefinition ) | ( ruleGateDefinition ) );
+    public final void rule__EventDefinition__Alternatives() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:527:1: ( ( ruleBasicEventDefinition ) | ( ruleGateDefinition ) )
+            int alt2=2;
+            int LA2_0 = input.LA(1);
+
+            if ( (LA2_0==RULE_ID) ) {
+                int LA2_1 = input.LA(2);
+
+                if ( (LA2_1==21) ) {
+                    alt2=1;
+                }
+                else if ( ((LA2_1>=23 && LA2_1<=24)) ) {
+                    alt2=2;
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 2, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 2, 0, input);
+
+                throw nvae;
+            }
+            switch (alt2) {
+                case 1 :
+                    // InternalCftLanguage.g:528:2: ( ruleBasicEventDefinition )
+                    {
+                    // InternalCftLanguage.g:528:2: ( ruleBasicEventDefinition )
+                    // InternalCftLanguage.g:529:3: ruleBasicEventDefinition
+                    {
+                     before(grammarAccess.getEventDefinitionAccess().getBasicEventDefinitionParserRuleCall_0()); 
+                    pushFollow(FOLLOW_2);
+                    ruleBasicEventDefinition();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getEventDefinitionAccess().getBasicEventDefinitionParserRuleCall_0()); 
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalCftLanguage.g:534:2: ( ruleGateDefinition )
+                    {
+                    // InternalCftLanguage.g:534:2: ( ruleGateDefinition )
+                    // InternalCftLanguage.g:535:3: ruleGateDefinition
+                    {
+                     before(grammarAccess.getEventDefinitionAccess().getGateDefinitionParserRuleCall_1()); 
+                    pushFollow(FOLLOW_2);
+                    ruleGateDefinition();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getEventDefinitionAccess().getGateDefinitionParserRuleCall_1()); 
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventDefinition__Alternatives"
+
+
+    // $ANTLR start "rule__GateDefinition__Alternatives"
+    // InternalCftLanguage.g:544:1: rule__GateDefinition__Alternatives : ( ( ruleAndGate ) | ( ruleOrGate ) );
+    public final void rule__GateDefinition__Alternatives() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:548:1: ( ( ruleAndGate ) | ( ruleOrGate ) )
+            int alt3=2;
+            int LA3_0 = input.LA(1);
+
+            if ( (LA3_0==RULE_ID) ) {
+                int LA3_1 = input.LA(2);
+
+                if ( (LA3_1==23) ) {
+                    alt3=1;
+                }
+                else if ( (LA3_1==24) ) {
+                    alt3=2;
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 3, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 3, 0, input);
+
+                throw nvae;
+            }
+            switch (alt3) {
+                case 1 :
+                    // InternalCftLanguage.g:549:2: ( ruleAndGate )
+                    {
+                    // InternalCftLanguage.g:549:2: ( ruleAndGate )
+                    // InternalCftLanguage.g:550:3: ruleAndGate
+                    {
+                     before(grammarAccess.getGateDefinitionAccess().getAndGateParserRuleCall_0()); 
+                    pushFollow(FOLLOW_2);
+                    ruleAndGate();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getGateDefinitionAccess().getAndGateParserRuleCall_0()); 
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalCftLanguage.g:555:2: ( ruleOrGate )
+                    {
+                    // InternalCftLanguage.g:555:2: ( ruleOrGate )
+                    // InternalCftLanguage.g:556:3: ruleOrGate
+                    {
+                     before(grammarAccess.getGateDefinitionAccess().getOrGateParserRuleCall_1()); 
+                    pushFollow(FOLLOW_2);
+                    ruleOrGate();
+
+                    state._fsp--;
+
+                     after(grammarAccess.getGateDefinitionAccess().getOrGateParserRuleCall_1()); 
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__GateDefinition__Alternatives"
+
+
+    // $ANTLR start "rule__MappingDefinition__Alternatives_8_1_0"
+    // InternalCftLanguage.g:565:1: rule__MappingDefinition__Alternatives_8_1_0 : ( ( ( rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 ) ) | ( ( rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 ) ) );
+    public final void rule__MappingDefinition__Alternatives_8_1_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:569:1: ( ( ( rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 ) ) | ( ( rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 ) ) )
+            int alt4=2;
+            int LA4_0 = input.LA(1);
+
+            if ( (LA4_0==30) ) {
+                alt4=1;
+            }
+            else if ( (LA4_0==RULE_ID) ) {
+                alt4=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 4, 0, input);
+
+                throw nvae;
+            }
+            switch (alt4) {
+                case 1 :
+                    // InternalCftLanguage.g:570:2: ( ( rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 ) )
+                    {
+                    // InternalCftLanguage.g:570:2: ( ( rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 ) )
+                    // InternalCftLanguage.g:571:3: ( rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 )
+                    {
+                     before(grammarAccess.getMappingDefinitionAccess().getLookupDefinitionsAssignment_8_1_0_0()); 
+                    // InternalCftLanguage.g:572:3: ( rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 )
+                    // InternalCftLanguage.g:572:4: rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getMappingDefinitionAccess().getLookupDefinitionsAssignment_8_1_0_0()); 
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalCftLanguage.g:576:2: ( ( rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 ) )
+                    {
+                    // InternalCftLanguage.g:576:2: ( ( rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 ) )
+                    // InternalCftLanguage.g:577:3: ( rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 )
+                    {
+                     before(grammarAccess.getMappingDefinitionAccess().getAssignmentsAssignment_8_1_0_1()); 
+                    // InternalCftLanguage.g:578:3: ( rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 )
+                    // InternalCftLanguage.g:578:4: rule__MappingDefinition__AssignmentsAssignment_8_1_0_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__MappingDefinition__AssignmentsAssignment_8_1_0_1();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getMappingDefinitionAccess().getAssignmentsAssignment_8_1_0_1()); 
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Alternatives_8_1_0"
+
+
+    // $ANTLR start "rule__Assignment__Alternatives_1"
+    // InternalCftLanguage.g:586:1: rule__Assignment__Alternatives_1 : ( ( ( rule__Assignment__MultipleAssignment_1_0 ) ) | ( ':=' ) );
+    public final void rule__Assignment__Alternatives_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:590:1: ( ( ( rule__Assignment__MultipleAssignment_1_0 ) ) | ( ':=' ) )
+            int alt5=2;
+            int LA5_0 = input.LA(1);
+
+            if ( (LA5_0==37) ) {
+                alt5=1;
+            }
+            else if ( (LA5_0==12) ) {
+                alt5=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 5, 0, input);
+
+                throw nvae;
+            }
+            switch (alt5) {
+                case 1 :
+                    // InternalCftLanguage.g:591:2: ( ( rule__Assignment__MultipleAssignment_1_0 ) )
+                    {
+                    // InternalCftLanguage.g:591:2: ( ( rule__Assignment__MultipleAssignment_1_0 ) )
+                    // InternalCftLanguage.g:592:3: ( rule__Assignment__MultipleAssignment_1_0 )
+                    {
+                     before(grammarAccess.getAssignmentAccess().getMultipleAssignment_1_0()); 
+                    // InternalCftLanguage.g:593:3: ( rule__Assignment__MultipleAssignment_1_0 )
+                    // InternalCftLanguage.g:593:4: rule__Assignment__MultipleAssignment_1_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__Assignment__MultipleAssignment_1_0();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getAssignmentAccess().getMultipleAssignment_1_0()); 
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalCftLanguage.g:597:2: ( ':=' )
+                    {
+                    // InternalCftLanguage.g:597:2: ( ':=' )
+                    // InternalCftLanguage.g:598:3: ':='
+                    {
+                     before(grammarAccess.getAssignmentAccess().getColonEqualsSignKeyword_1_1()); 
+                    match(input,12,FOLLOW_2); 
+                     after(grammarAccess.getAssignmentAccess().getColonEqualsSignKeyword_1_1()); 
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Alternatives_1"
+
+
+    // $ANTLR start "rule__CftModel__Group__0"
+    // InternalCftLanguage.g:607:1: rule__CftModel__Group__0 : rule__CftModel__Group__0__Impl rule__CftModel__Group__1 ;
+    public final void rule__CftModel__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:611:1: ( rule__CftModel__Group__0__Impl rule__CftModel__Group__1 )
+            // InternalCftLanguage.g:612:2: rule__CftModel__Group__0__Impl rule__CftModel__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__CftModel__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__CftModel__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__0"
+
+
+    // $ANTLR start "rule__CftModel__Group__0__Impl"
+    // InternalCftLanguage.g:619:1: rule__CftModel__Group__0__Impl : ( 'package' ) ;
+    public final void rule__CftModel__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:623:1: ( ( 'package' ) )
+            // InternalCftLanguage.g:624:1: ( 'package' )
+            {
+            // InternalCftLanguage.g:624:1: ( 'package' )
+            // InternalCftLanguage.g:625:2: 'package'
+            {
+             before(grammarAccess.getCftModelAccess().getPackageKeyword_0()); 
+            match(input,13,FOLLOW_2); 
+             after(grammarAccess.getCftModelAccess().getPackageKeyword_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__0__Impl"
+
+
+    // $ANTLR start "rule__CftModel__Group__1"
+    // InternalCftLanguage.g:634:1: rule__CftModel__Group__1 : rule__CftModel__Group__1__Impl rule__CftModel__Group__2 ;
+    public final void rule__CftModel__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:638:1: ( rule__CftModel__Group__1__Impl rule__CftModel__Group__2 )
+            // InternalCftLanguage.g:639:2: rule__CftModel__Group__1__Impl rule__CftModel__Group__2
+            {
+            pushFollow(FOLLOW_4);
+            rule__CftModel__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__CftModel__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__1"
+
+
+    // $ANTLR start "rule__CftModel__Group__1__Impl"
+    // InternalCftLanguage.g:646:1: rule__CftModel__Group__1__Impl : ( ( rule__CftModel__PackageNameAssignment_1 ) ) ;
+    public final void rule__CftModel__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:650:1: ( ( ( rule__CftModel__PackageNameAssignment_1 ) ) )
+            // InternalCftLanguage.g:651:1: ( ( rule__CftModel__PackageNameAssignment_1 ) )
+            {
+            // InternalCftLanguage.g:651:1: ( ( rule__CftModel__PackageNameAssignment_1 ) )
+            // InternalCftLanguage.g:652:2: ( rule__CftModel__PackageNameAssignment_1 )
+            {
+             before(grammarAccess.getCftModelAccess().getPackageNameAssignment_1()); 
+            // InternalCftLanguage.g:653:2: ( rule__CftModel__PackageNameAssignment_1 )
+            // InternalCftLanguage.g:653:3: rule__CftModel__PackageNameAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__CftModel__PackageNameAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getCftModelAccess().getPackageNameAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__1__Impl"
+
+
+    // $ANTLR start "rule__CftModel__Group__2"
+    // InternalCftLanguage.g:661:1: rule__CftModel__Group__2 : rule__CftModel__Group__2__Impl rule__CftModel__Group__3 ;
+    public final void rule__CftModel__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:665:1: ( rule__CftModel__Group__2__Impl rule__CftModel__Group__3 )
+            // InternalCftLanguage.g:666:2: rule__CftModel__Group__2__Impl rule__CftModel__Group__3
+            {
+            pushFollow(FOLLOW_4);
+            rule__CftModel__Group__2__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__CftModel__Group__3();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__2"
+
+
+    // $ANTLR start "rule__CftModel__Group__2__Impl"
+    // InternalCftLanguage.g:673:1: rule__CftModel__Group__2__Impl : ( ( ';' )? ) ;
+    public final void rule__CftModel__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:677:1: ( ( ( ';' )? ) )
+            // InternalCftLanguage.g:678:1: ( ( ';' )? )
+            {
+            // InternalCftLanguage.g:678:1: ( ( ';' )? )
+            // InternalCftLanguage.g:679:2: ( ';' )?
+            {
+             before(grammarAccess.getCftModelAccess().getSemicolonKeyword_2()); 
+            // InternalCftLanguage.g:680:2: ( ';' )?
+            int alt6=2;
+            int LA6_0 = input.LA(1);
+
+            if ( (LA6_0==14) ) {
+                alt6=1;
+            }
+            switch (alt6) {
+                case 1 :
+                    // InternalCftLanguage.g:680:3: ';'
+                    {
+                    match(input,14,FOLLOW_2); 
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getCftModelAccess().getSemicolonKeyword_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__2__Impl"
+
+
+    // $ANTLR start "rule__CftModel__Group__3"
+    // InternalCftLanguage.g:688:1: rule__CftModel__Group__3 : rule__CftModel__Group__3__Impl rule__CftModel__Group__4 ;
+    public final void rule__CftModel__Group__3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:692:1: ( rule__CftModel__Group__3__Impl rule__CftModel__Group__4 )
+            // InternalCftLanguage.g:693:2: rule__CftModel__Group__3__Impl rule__CftModel__Group__4
+            {
+            pushFollow(FOLLOW_4);
+            rule__CftModel__Group__3__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__CftModel__Group__4();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__3"
+
+
+    // $ANTLR start "rule__CftModel__Group__3__Impl"
+    // InternalCftLanguage.g:700:1: rule__CftModel__Group__3__Impl : ( ( rule__CftModel__ImportsAssignment_3 )* ) ;
+    public final void rule__CftModel__Group__3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:704:1: ( ( ( rule__CftModel__ImportsAssignment_3 )* ) )
+            // InternalCftLanguage.g:705:1: ( ( rule__CftModel__ImportsAssignment_3 )* )
+            {
+            // InternalCftLanguage.g:705:1: ( ( rule__CftModel__ImportsAssignment_3 )* )
+            // InternalCftLanguage.g:706:2: ( rule__CftModel__ImportsAssignment_3 )*
+            {
+             before(grammarAccess.getCftModelAccess().getImportsAssignment_3()); 
+            // InternalCftLanguage.g:707:2: ( rule__CftModel__ImportsAssignment_3 )*
+            loop7:
+            do {
+                int alt7=2;
+                int LA7_0 = input.LA(1);
+
+                if ( (LA7_0==15) ) {
+                    alt7=1;
+                }
+
+
+                switch (alt7) {
+                case 1 :
+                    // InternalCftLanguage.g:707:3: rule__CftModel__ImportsAssignment_3
+                    {
+                    pushFollow(FOLLOW_5);
+                    rule__CftModel__ImportsAssignment_3();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop7;
+                }
+            } while (true);
+
+             after(grammarAccess.getCftModelAccess().getImportsAssignment_3()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__3__Impl"
+
+
+    // $ANTLR start "rule__CftModel__Group__4"
+    // InternalCftLanguage.g:715:1: rule__CftModel__Group__4 : rule__CftModel__Group__4__Impl ;
+    public final void rule__CftModel__Group__4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:719:1: ( rule__CftModel__Group__4__Impl )
+            // InternalCftLanguage.g:720:2: rule__CftModel__Group__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__CftModel__Group__4__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__4"
+
+
+    // $ANTLR start "rule__CftModel__Group__4__Impl"
+    // InternalCftLanguage.g:726:1: rule__CftModel__Group__4__Impl : ( ( rule__CftModel__Alternatives_4 )* ) ;
+    public final void rule__CftModel__Group__4__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:730:1: ( ( ( rule__CftModel__Alternatives_4 )* ) )
+            // InternalCftLanguage.g:731:1: ( ( rule__CftModel__Alternatives_4 )* )
+            {
+            // InternalCftLanguage.g:731:1: ( ( rule__CftModel__Alternatives_4 )* )
+            // InternalCftLanguage.g:732:2: ( rule__CftModel__Alternatives_4 )*
+            {
+             before(grammarAccess.getCftModelAccess().getAlternatives_4()); 
+            // InternalCftLanguage.g:733:2: ( rule__CftModel__Alternatives_4 )*
+            loop8:
+            do {
+                int alt8=2;
+                int LA8_0 = input.LA(1);
+
+                if ( (LA8_0==16||LA8_0==25) ) {
+                    alt8=1;
+                }
+
+
+                switch (alt8) {
+                case 1 :
+                    // InternalCftLanguage.g:733:3: rule__CftModel__Alternatives_4
+                    {
+                    pushFollow(FOLLOW_6);
+                    rule__CftModel__Alternatives_4();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop8;
+                }
+            } while (true);
+
+             after(grammarAccess.getCftModelAccess().getAlternatives_4()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__Group__4__Impl"
+
+
+    // $ANTLR start "rule__ImportDeclaration__Group__0"
+    // InternalCftLanguage.g:742:1: rule__ImportDeclaration__Group__0 : rule__ImportDeclaration__Group__0__Impl rule__ImportDeclaration__Group__1 ;
+    public final void rule__ImportDeclaration__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:746:1: ( rule__ImportDeclaration__Group__0__Impl rule__ImportDeclaration__Group__1 )
+            // InternalCftLanguage.g:747:2: rule__ImportDeclaration__Group__0__Impl rule__ImportDeclaration__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__ImportDeclaration__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ImportDeclaration__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__Group__0"
+
+
+    // $ANTLR start "rule__ImportDeclaration__Group__0__Impl"
+    // InternalCftLanguage.g:754:1: rule__ImportDeclaration__Group__0__Impl : ( 'import' ) ;
+    public final void rule__ImportDeclaration__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:758:1: ( ( 'import' ) )
+            // InternalCftLanguage.g:759:1: ( 'import' )
+            {
+            // InternalCftLanguage.g:759:1: ( 'import' )
+            // InternalCftLanguage.g:760:2: 'import'
+            {
+             before(grammarAccess.getImportDeclarationAccess().getImportKeyword_0()); 
+            match(input,15,FOLLOW_2); 
+             after(grammarAccess.getImportDeclarationAccess().getImportKeyword_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__Group__0__Impl"
+
+
+    // $ANTLR start "rule__ImportDeclaration__Group__1"
+    // InternalCftLanguage.g:769:1: rule__ImportDeclaration__Group__1 : rule__ImportDeclaration__Group__1__Impl rule__ImportDeclaration__Group__2 ;
+    public final void rule__ImportDeclaration__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:773:1: ( rule__ImportDeclaration__Group__1__Impl rule__ImportDeclaration__Group__2 )
+            // InternalCftLanguage.g:774:2: rule__ImportDeclaration__Group__1__Impl rule__ImportDeclaration__Group__2
+            {
+            pushFollow(FOLLOW_7);
+            rule__ImportDeclaration__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ImportDeclaration__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__Group__1"
+
+
+    // $ANTLR start "rule__ImportDeclaration__Group__1__Impl"
+    // InternalCftLanguage.g:781:1: rule__ImportDeclaration__Group__1__Impl : ( ( rule__ImportDeclaration__ImportedNamespaceAssignment_1 ) ) ;
+    public final void rule__ImportDeclaration__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:785:1: ( ( ( rule__ImportDeclaration__ImportedNamespaceAssignment_1 ) ) )
+            // InternalCftLanguage.g:786:1: ( ( rule__ImportDeclaration__ImportedNamespaceAssignment_1 ) )
+            {
+            // InternalCftLanguage.g:786:1: ( ( rule__ImportDeclaration__ImportedNamespaceAssignment_1 ) )
+            // InternalCftLanguage.g:787:2: ( rule__ImportDeclaration__ImportedNamespaceAssignment_1 )
+            {
+             before(grammarAccess.getImportDeclarationAccess().getImportedNamespaceAssignment_1()); 
+            // InternalCftLanguage.g:788:2: ( rule__ImportDeclaration__ImportedNamespaceAssignment_1 )
+            // InternalCftLanguage.g:788:3: rule__ImportDeclaration__ImportedNamespaceAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__ImportDeclaration__ImportedNamespaceAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getImportDeclarationAccess().getImportedNamespaceAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__Group__1__Impl"
+
+
+    // $ANTLR start "rule__ImportDeclaration__Group__2"
+    // InternalCftLanguage.g:796:1: rule__ImportDeclaration__Group__2 : rule__ImportDeclaration__Group__2__Impl ;
+    public final void rule__ImportDeclaration__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:800:1: ( rule__ImportDeclaration__Group__2__Impl )
+            // InternalCftLanguage.g:801:2: rule__ImportDeclaration__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ImportDeclaration__Group__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__Group__2"
+
+
+    // $ANTLR start "rule__ImportDeclaration__Group__2__Impl"
+    // InternalCftLanguage.g:807:1: rule__ImportDeclaration__Group__2__Impl : ( ( ';' )? ) ;
+    public final void rule__ImportDeclaration__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:811:1: ( ( ( ';' )? ) )
+            // InternalCftLanguage.g:812:1: ( ( ';' )? )
+            {
+            // InternalCftLanguage.g:812:1: ( ( ';' )? )
+            // InternalCftLanguage.g:813:2: ( ';' )?
+            {
+             before(grammarAccess.getImportDeclarationAccess().getSemicolonKeyword_2()); 
+            // InternalCftLanguage.g:814:2: ( ';' )?
+            int alt9=2;
+            int LA9_0 = input.LA(1);
+
+            if ( (LA9_0==14) ) {
+                alt9=1;
+            }
+            switch (alt9) {
+                case 1 :
+                    // InternalCftLanguage.g:814:3: ';'
+                    {
+                    match(input,14,FOLLOW_2); 
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getImportDeclarationAccess().getSemicolonKeyword_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__Group__2__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__0"
+    // InternalCftLanguage.g:823:1: rule__ComponentDefinition__Group__0 : rule__ComponentDefinition__Group__0__Impl rule__ComponentDefinition__Group__1 ;
+    public final void rule__ComponentDefinition__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:827:1: ( rule__ComponentDefinition__Group__0__Impl rule__ComponentDefinition__Group__1 )
+            // InternalCftLanguage.g:828:2: rule__ComponentDefinition__Group__0__Impl rule__ComponentDefinition__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__ComponentDefinition__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__0"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__0__Impl"
+    // InternalCftLanguage.g:835:1: rule__ComponentDefinition__Group__0__Impl : ( 'cft' ) ;
+    public final void rule__ComponentDefinition__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:839:1: ( ( 'cft' ) )
+            // InternalCftLanguage.g:840:1: ( 'cft' )
+            {
+            // InternalCftLanguage.g:840:1: ( 'cft' )
+            // InternalCftLanguage.g:841:2: 'cft'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getCftKeyword_0()); 
+            match(input,16,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getCftKeyword_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__0__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__1"
+    // InternalCftLanguage.g:850:1: rule__ComponentDefinition__Group__1 : rule__ComponentDefinition__Group__1__Impl rule__ComponentDefinition__Group__2 ;
+    public final void rule__ComponentDefinition__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:854:1: ( rule__ComponentDefinition__Group__1__Impl rule__ComponentDefinition__Group__2 )
+            // InternalCftLanguage.g:855:2: rule__ComponentDefinition__Group__1__Impl rule__ComponentDefinition__Group__2
+            {
+            pushFollow(FOLLOW_8);
+            rule__ComponentDefinition__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__1__Impl"
+    // InternalCftLanguage.g:862:1: rule__ComponentDefinition__Group__1__Impl : ( ( rule__ComponentDefinition__NameAssignment_1 ) ) ;
+    public final void rule__ComponentDefinition__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:866:1: ( ( ( rule__ComponentDefinition__NameAssignment_1 ) ) )
+            // InternalCftLanguage.g:867:1: ( ( rule__ComponentDefinition__NameAssignment_1 ) )
+            {
+            // InternalCftLanguage.g:867:1: ( ( rule__ComponentDefinition__NameAssignment_1 ) )
+            // InternalCftLanguage.g:868:2: ( rule__ComponentDefinition__NameAssignment_1 )
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getNameAssignment_1()); 
+            // InternalCftLanguage.g:869:2: ( rule__ComponentDefinition__NameAssignment_1 )
+            // InternalCftLanguage.g:869:3: rule__ComponentDefinition__NameAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__NameAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getComponentDefinitionAccess().getNameAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__1__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__2"
+    // InternalCftLanguage.g:877:1: rule__ComponentDefinition__Group__2 : rule__ComponentDefinition__Group__2__Impl rule__ComponentDefinition__Group__3 ;
+    public final void rule__ComponentDefinition__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:881:1: ( rule__ComponentDefinition__Group__2__Impl rule__ComponentDefinition__Group__3 )
+            // InternalCftLanguage.g:882:2: rule__ComponentDefinition__Group__2__Impl rule__ComponentDefinition__Group__3
+            {
+            pushFollow(FOLLOW_9);
+            rule__ComponentDefinition__Group__2__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__3();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__2"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__2__Impl"
+    // InternalCftLanguage.g:889:1: rule__ComponentDefinition__Group__2__Impl : ( '{' ) ;
+    public final void rule__ComponentDefinition__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:893:1: ( ( '{' ) )
+            // InternalCftLanguage.g:894:1: ( '{' )
+            {
+            // InternalCftLanguage.g:894:1: ( '{' )
+            // InternalCftLanguage.g:895:2: '{'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getLeftCurlyBracketKeyword_2()); 
+            match(input,17,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getLeftCurlyBracketKeyword_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__2__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__3"
+    // InternalCftLanguage.g:904:1: rule__ComponentDefinition__Group__3 : rule__ComponentDefinition__Group__3__Impl rule__ComponentDefinition__Group__4 ;
+    public final void rule__ComponentDefinition__Group__3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:908:1: ( rule__ComponentDefinition__Group__3__Impl rule__ComponentDefinition__Group__4 )
+            // InternalCftLanguage.g:909:2: rule__ComponentDefinition__Group__3__Impl rule__ComponentDefinition__Group__4
+            {
+            pushFollow(FOLLOW_10);
+            rule__ComponentDefinition__Group__3__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__4();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__3"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__3__Impl"
+    // InternalCftLanguage.g:916:1: rule__ComponentDefinition__Group__3__Impl : ( ( rule__ComponentDefinition__UnorderedGroup_3 ) ) ;
+    public final void rule__ComponentDefinition__Group__3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:920:1: ( ( ( rule__ComponentDefinition__UnorderedGroup_3 ) ) )
+            // InternalCftLanguage.g:921:1: ( ( rule__ComponentDefinition__UnorderedGroup_3 ) )
+            {
+            // InternalCftLanguage.g:921:1: ( ( rule__ComponentDefinition__UnorderedGroup_3 ) )
+            // InternalCftLanguage.g:922:2: ( rule__ComponentDefinition__UnorderedGroup_3 )
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3()); 
+            // InternalCftLanguage.g:923:2: ( rule__ComponentDefinition__UnorderedGroup_3 )
+            // InternalCftLanguage.g:923:3: rule__ComponentDefinition__UnorderedGroup_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__UnorderedGroup_3();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__3__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__4"
+    // InternalCftLanguage.g:931:1: rule__ComponentDefinition__Group__4 : rule__ComponentDefinition__Group__4__Impl rule__ComponentDefinition__Group__5 ;
+    public final void rule__ComponentDefinition__Group__4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:935:1: ( rule__ComponentDefinition__Group__4__Impl rule__ComponentDefinition__Group__5 )
+            // InternalCftLanguage.g:936:2: rule__ComponentDefinition__Group__4__Impl rule__ComponentDefinition__Group__5
+            {
+            pushFollow(FOLLOW_10);
+            rule__ComponentDefinition__Group__4__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__5();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__4"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__4__Impl"
+    // InternalCftLanguage.g:943:1: rule__ComponentDefinition__Group__4__Impl : ( ( rule__ComponentDefinition__Group_4__0 )* ) ;
+    public final void rule__ComponentDefinition__Group__4__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:947:1: ( ( ( rule__ComponentDefinition__Group_4__0 )* ) )
+            // InternalCftLanguage.g:948:1: ( ( rule__ComponentDefinition__Group_4__0 )* )
+            {
+            // InternalCftLanguage.g:948:1: ( ( rule__ComponentDefinition__Group_4__0 )* )
+            // InternalCftLanguage.g:949:2: ( rule__ComponentDefinition__Group_4__0 )*
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getGroup_4()); 
+            // InternalCftLanguage.g:950:2: ( rule__ComponentDefinition__Group_4__0 )*
+            loop10:
+            do {
+                int alt10=2;
+                int LA10_0 = input.LA(1);
+
+                if ( (LA10_0==RULE_ID) ) {
+                    alt10=1;
+                }
+
+
+                switch (alt10) {
+                case 1 :
+                    // InternalCftLanguage.g:950:3: rule__ComponentDefinition__Group_4__0
+                    {
+                    pushFollow(FOLLOW_11);
+                    rule__ComponentDefinition__Group_4__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop10;
+                }
+            } while (true);
+
+             after(grammarAccess.getComponentDefinitionAccess().getGroup_4()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__4__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__5"
+    // InternalCftLanguage.g:958:1: rule__ComponentDefinition__Group__5 : rule__ComponentDefinition__Group__5__Impl ;
+    public final void rule__ComponentDefinition__Group__5() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:962:1: ( rule__ComponentDefinition__Group__5__Impl )
+            // InternalCftLanguage.g:963:2: rule__ComponentDefinition__Group__5__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group__5__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__5"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group__5__Impl"
+    // InternalCftLanguage.g:969:1: rule__ComponentDefinition__Group__5__Impl : ( '}' ) ;
+    public final void rule__ComponentDefinition__Group__5__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:973:1: ( ( '}' ) )
+            // InternalCftLanguage.g:974:1: ( '}' )
+            {
+            // InternalCftLanguage.g:974:1: ( '}' )
+            // InternalCftLanguage.g:975:2: '}'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getRightCurlyBracketKeyword_5()); 
+            match(input,18,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getRightCurlyBracketKeyword_5()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group__5__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_0__0"
+    // InternalCftLanguage.g:985:1: rule__ComponentDefinition__Group_3_0__0 : rule__ComponentDefinition__Group_3_0__0__Impl rule__ComponentDefinition__Group_3_0__1 ;
+    public final void rule__ComponentDefinition__Group_3_0__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:989:1: ( rule__ComponentDefinition__Group_3_0__0__Impl rule__ComponentDefinition__Group_3_0__1 )
+            // InternalCftLanguage.g:990:2: rule__ComponentDefinition__Group_3_0__0__Impl rule__ComponentDefinition__Group_3_0__1
+            {
+            pushFollow(FOLLOW_12);
+            rule__ComponentDefinition__Group_3_0__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_3_0__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_0__0"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_0__0__Impl"
+    // InternalCftLanguage.g:997:1: rule__ComponentDefinition__Group_3_0__0__Impl : ( 'in' ) ;
+    public final void rule__ComponentDefinition__Group_3_0__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1001:1: ( ( 'in' ) )
+            // InternalCftLanguage.g:1002:1: ( 'in' )
+            {
+            // InternalCftLanguage.g:1002:1: ( 'in' )
+            // InternalCftLanguage.g:1003:2: 'in'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getInKeyword_3_0_0()); 
+            match(input,19,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getInKeyword_3_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_0__0__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_0__1"
+    // InternalCftLanguage.g:1012:1: rule__ComponentDefinition__Group_3_0__1 : rule__ComponentDefinition__Group_3_0__1__Impl rule__ComponentDefinition__Group_3_0__2 ;
+    public final void rule__ComponentDefinition__Group_3_0__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1016:1: ( rule__ComponentDefinition__Group_3_0__1__Impl rule__ComponentDefinition__Group_3_0__2 )
+            // InternalCftLanguage.g:1017:2: rule__ComponentDefinition__Group_3_0__1__Impl rule__ComponentDefinition__Group_3_0__2
+            {
+            pushFollow(FOLLOW_12);
+            rule__ComponentDefinition__Group_3_0__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_3_0__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_0__1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_0__1__Impl"
+    // InternalCftLanguage.g:1024:1: rule__ComponentDefinition__Group_3_0__1__Impl : ( ( rule__ComponentDefinition__InputEventsAssignment_3_0_1 )* ) ;
+    public final void rule__ComponentDefinition__Group_3_0__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1028:1: ( ( ( rule__ComponentDefinition__InputEventsAssignment_3_0_1 )* ) )
+            // InternalCftLanguage.g:1029:1: ( ( rule__ComponentDefinition__InputEventsAssignment_3_0_1 )* )
+            {
+            // InternalCftLanguage.g:1029:1: ( ( rule__ComponentDefinition__InputEventsAssignment_3_0_1 )* )
+            // InternalCftLanguage.g:1030:2: ( rule__ComponentDefinition__InputEventsAssignment_3_0_1 )*
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getInputEventsAssignment_3_0_1()); 
+            // InternalCftLanguage.g:1031:2: ( rule__ComponentDefinition__InputEventsAssignment_3_0_1 )*
+            loop11:
+            do {
+                int alt11=2;
+                int LA11_0 = input.LA(1);
+
+                if ( (LA11_0==RULE_ID) ) {
+                    alt11=1;
+                }
+
+
+                switch (alt11) {
+                case 1 :
+                    // InternalCftLanguage.g:1031:3: rule__ComponentDefinition__InputEventsAssignment_3_0_1
+                    {
+                    pushFollow(FOLLOW_11);
+                    rule__ComponentDefinition__InputEventsAssignment_3_0_1();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop11;
+                }
+            } while (true);
+
+             after(grammarAccess.getComponentDefinitionAccess().getInputEventsAssignment_3_0_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_0__1__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_0__2"
+    // InternalCftLanguage.g:1039:1: rule__ComponentDefinition__Group_3_0__2 : rule__ComponentDefinition__Group_3_0__2__Impl ;
+    public final void rule__ComponentDefinition__Group_3_0__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1043:1: ( rule__ComponentDefinition__Group_3_0__2__Impl )
+            // InternalCftLanguage.g:1044:2: rule__ComponentDefinition__Group_3_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_3_0__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_0__2"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_0__2__Impl"
+    // InternalCftLanguage.g:1050:1: rule__ComponentDefinition__Group_3_0__2__Impl : ( ';' ) ;
+    public final void rule__ComponentDefinition__Group_3_0__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1054:1: ( ( ';' ) )
+            // InternalCftLanguage.g:1055:1: ( ';' )
+            {
+            // InternalCftLanguage.g:1055:1: ( ';' )
+            // InternalCftLanguage.g:1056:2: ';'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_0_2()); 
+            match(input,14,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_0_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_0__2__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_1__0"
+    // InternalCftLanguage.g:1066:1: rule__ComponentDefinition__Group_3_1__0 : rule__ComponentDefinition__Group_3_1__0__Impl rule__ComponentDefinition__Group_3_1__1 ;
+    public final void rule__ComponentDefinition__Group_3_1__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1070:1: ( rule__ComponentDefinition__Group_3_1__0__Impl rule__ComponentDefinition__Group_3_1__1 )
+            // InternalCftLanguage.g:1071:2: rule__ComponentDefinition__Group_3_1__0__Impl rule__ComponentDefinition__Group_3_1__1
+            {
+            pushFollow(FOLLOW_12);
+            rule__ComponentDefinition__Group_3_1__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_3_1__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_1__0"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_1__0__Impl"
+    // InternalCftLanguage.g:1078:1: rule__ComponentDefinition__Group_3_1__0__Impl : ( 'out' ) ;
+    public final void rule__ComponentDefinition__Group_3_1__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1082:1: ( ( 'out' ) )
+            // InternalCftLanguage.g:1083:1: ( 'out' )
+            {
+            // InternalCftLanguage.g:1083:1: ( 'out' )
+            // InternalCftLanguage.g:1084:2: 'out'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getOutKeyword_3_1_0()); 
+            match(input,20,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getOutKeyword_3_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_1__0__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_1__1"
+    // InternalCftLanguage.g:1093:1: rule__ComponentDefinition__Group_3_1__1 : rule__ComponentDefinition__Group_3_1__1__Impl rule__ComponentDefinition__Group_3_1__2 ;
+    public final void rule__ComponentDefinition__Group_3_1__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1097:1: ( rule__ComponentDefinition__Group_3_1__1__Impl rule__ComponentDefinition__Group_3_1__2 )
+            // InternalCftLanguage.g:1098:2: rule__ComponentDefinition__Group_3_1__1__Impl rule__ComponentDefinition__Group_3_1__2
+            {
+            pushFollow(FOLLOW_12);
+            rule__ComponentDefinition__Group_3_1__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_3_1__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_1__1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_1__1__Impl"
+    // InternalCftLanguage.g:1105:1: rule__ComponentDefinition__Group_3_1__1__Impl : ( ( rule__ComponentDefinition__OutputEventsAssignment_3_1_1 )* ) ;
+    public final void rule__ComponentDefinition__Group_3_1__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1109:1: ( ( ( rule__ComponentDefinition__OutputEventsAssignment_3_1_1 )* ) )
+            // InternalCftLanguage.g:1110:1: ( ( rule__ComponentDefinition__OutputEventsAssignment_3_1_1 )* )
+            {
+            // InternalCftLanguage.g:1110:1: ( ( rule__ComponentDefinition__OutputEventsAssignment_3_1_1 )* )
+            // InternalCftLanguage.g:1111:2: ( rule__ComponentDefinition__OutputEventsAssignment_3_1_1 )*
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getOutputEventsAssignment_3_1_1()); 
+            // InternalCftLanguage.g:1112:2: ( rule__ComponentDefinition__OutputEventsAssignment_3_1_1 )*
+            loop12:
+            do {
+                int alt12=2;
+                int LA12_0 = input.LA(1);
+
+                if ( (LA12_0==RULE_ID) ) {
+                    alt12=1;
+                }
+
+
+                switch (alt12) {
+                case 1 :
+                    // InternalCftLanguage.g:1112:3: rule__ComponentDefinition__OutputEventsAssignment_3_1_1
+                    {
+                    pushFollow(FOLLOW_11);
+                    rule__ComponentDefinition__OutputEventsAssignment_3_1_1();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop12;
+                }
+            } while (true);
+
+             after(grammarAccess.getComponentDefinitionAccess().getOutputEventsAssignment_3_1_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_1__1__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_1__2"
+    // InternalCftLanguage.g:1120:1: rule__ComponentDefinition__Group_3_1__2 : rule__ComponentDefinition__Group_3_1__2__Impl ;
+    public final void rule__ComponentDefinition__Group_3_1__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1124:1: ( rule__ComponentDefinition__Group_3_1__2__Impl )
+            // InternalCftLanguage.g:1125:2: rule__ComponentDefinition__Group_3_1__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_3_1__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_1__2"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_3_1__2__Impl"
+    // InternalCftLanguage.g:1131:1: rule__ComponentDefinition__Group_3_1__2__Impl : ( ';' ) ;
+    public final void rule__ComponentDefinition__Group_3_1__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1135:1: ( ( ';' ) )
+            // InternalCftLanguage.g:1136:1: ( ';' )
+            {
+            // InternalCftLanguage.g:1136:1: ( ';' )
+            // InternalCftLanguage.g:1137:2: ';'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_1_2()); 
+            match(input,14,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_1_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_3_1__2__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_4__0"
+    // InternalCftLanguage.g:1147:1: rule__ComponentDefinition__Group_4__0 : rule__ComponentDefinition__Group_4__0__Impl rule__ComponentDefinition__Group_4__1 ;
+    public final void rule__ComponentDefinition__Group_4__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1151:1: ( rule__ComponentDefinition__Group_4__0__Impl rule__ComponentDefinition__Group_4__1 )
+            // InternalCftLanguage.g:1152:2: rule__ComponentDefinition__Group_4__0__Impl rule__ComponentDefinition__Group_4__1
+            {
+            pushFollow(FOLLOW_7);
+            rule__ComponentDefinition__Group_4__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_4__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_4__0"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_4__0__Impl"
+    // InternalCftLanguage.g:1159:1: rule__ComponentDefinition__Group_4__0__Impl : ( ( rule__ComponentDefinition__EventDefinitionsAssignment_4_0 ) ) ;
+    public final void rule__ComponentDefinition__Group_4__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1163:1: ( ( ( rule__ComponentDefinition__EventDefinitionsAssignment_4_0 ) ) )
+            // InternalCftLanguage.g:1164:1: ( ( rule__ComponentDefinition__EventDefinitionsAssignment_4_0 ) )
+            {
+            // InternalCftLanguage.g:1164:1: ( ( rule__ComponentDefinition__EventDefinitionsAssignment_4_0 ) )
+            // InternalCftLanguage.g:1165:2: ( rule__ComponentDefinition__EventDefinitionsAssignment_4_0 )
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getEventDefinitionsAssignment_4_0()); 
+            // InternalCftLanguage.g:1166:2: ( rule__ComponentDefinition__EventDefinitionsAssignment_4_0 )
+            // InternalCftLanguage.g:1166:3: rule__ComponentDefinition__EventDefinitionsAssignment_4_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__EventDefinitionsAssignment_4_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getComponentDefinitionAccess().getEventDefinitionsAssignment_4_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_4__0__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_4__1"
+    // InternalCftLanguage.g:1174:1: rule__ComponentDefinition__Group_4__1 : rule__ComponentDefinition__Group_4__1__Impl ;
+    public final void rule__ComponentDefinition__Group_4__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1178:1: ( rule__ComponentDefinition__Group_4__1__Impl )
+            // InternalCftLanguage.g:1179:2: rule__ComponentDefinition__Group_4__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__Group_4__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_4__1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__Group_4__1__Impl"
+    // InternalCftLanguage.g:1185:1: rule__ComponentDefinition__Group_4__1__Impl : ( ';' ) ;
+    public final void rule__ComponentDefinition__Group_4__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1189:1: ( ( ';' ) )
+            // InternalCftLanguage.g:1190:1: ( ';' )
+            {
+            // InternalCftLanguage.g:1190:1: ( ';' )
+            // InternalCftLanguage.g:1191:2: ';'
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_4_1()); 
+            match(input,14,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_4_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__Group_4__1__Impl"
+
+
+    // $ANTLR start "rule__InputEvent__Group__0"
+    // InternalCftLanguage.g:1201:1: rule__InputEvent__Group__0 : rule__InputEvent__Group__0__Impl rule__InputEvent__Group__1 ;
+    public final void rule__InputEvent__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1205:1: ( rule__InputEvent__Group__0__Impl rule__InputEvent__Group__1 )
+            // InternalCftLanguage.g:1206:2: rule__InputEvent__Group__0__Impl rule__InputEvent__Group__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__InputEvent__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__InputEvent__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__InputEvent__Group__0"
+
+
+    // $ANTLR start "rule__InputEvent__Group__0__Impl"
+    // InternalCftLanguage.g:1213:1: rule__InputEvent__Group__0__Impl : ( ( rule__InputEvent__NameAssignment_0 ) ) ;
+    public final void rule__InputEvent__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1217:1: ( ( ( rule__InputEvent__NameAssignment_0 ) ) )
+            // InternalCftLanguage.g:1218:1: ( ( rule__InputEvent__NameAssignment_0 ) )
+            {
+            // InternalCftLanguage.g:1218:1: ( ( rule__InputEvent__NameAssignment_0 ) )
+            // InternalCftLanguage.g:1219:2: ( rule__InputEvent__NameAssignment_0 )
+            {
+             before(grammarAccess.getInputEventAccess().getNameAssignment_0()); 
+            // InternalCftLanguage.g:1220:2: ( rule__InputEvent__NameAssignment_0 )
+            // InternalCftLanguage.g:1220:3: rule__InputEvent__NameAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__InputEvent__NameAssignment_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getInputEventAccess().getNameAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__InputEvent__Group__0__Impl"
+
+
+    // $ANTLR start "rule__InputEvent__Group__1"
+    // InternalCftLanguage.g:1228:1: rule__InputEvent__Group__1 : rule__InputEvent__Group__1__Impl ;
+    public final void rule__InputEvent__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1232:1: ( rule__InputEvent__Group__1__Impl )
+            // InternalCftLanguage.g:1233:2: rule__InputEvent__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__InputEvent__Group__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__InputEvent__Group__1"
+
+
+    // $ANTLR start "rule__InputEvent__Group__1__Impl"
+    // InternalCftLanguage.g:1239:1: rule__InputEvent__Group__1__Impl : ( ( rule__InputEvent__MultipleAssignment_1 )? ) ;
+    public final void rule__InputEvent__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1243:1: ( ( ( rule__InputEvent__MultipleAssignment_1 )? ) )
+            // InternalCftLanguage.g:1244:1: ( ( rule__InputEvent__MultipleAssignment_1 )? )
+            {
+            // InternalCftLanguage.g:1244:1: ( ( rule__InputEvent__MultipleAssignment_1 )? )
+            // InternalCftLanguage.g:1245:2: ( rule__InputEvent__MultipleAssignment_1 )?
+            {
+             before(grammarAccess.getInputEventAccess().getMultipleAssignment_1()); 
+            // InternalCftLanguage.g:1246:2: ( rule__InputEvent__MultipleAssignment_1 )?
+            int alt13=2;
+            int LA13_0 = input.LA(1);
+
+            if ( (LA13_0==35) ) {
+                alt13=1;
+            }
+            switch (alt13) {
+                case 1 :
+                    // InternalCftLanguage.g:1246:3: rule__InputEvent__MultipleAssignment_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__InputEvent__MultipleAssignment_1();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getInputEventAccess().getMultipleAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__InputEvent__Group__1__Impl"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__0"
+    // InternalCftLanguage.g:1255:1: rule__BasicEventDefinition__Group__0 : rule__BasicEventDefinition__Group__0__Impl rule__BasicEventDefinition__Group__1 ;
+    public final void rule__BasicEventDefinition__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1259:1: ( rule__BasicEventDefinition__Group__0__Impl rule__BasicEventDefinition__Group__1 )
+            // InternalCftLanguage.g:1260:2: rule__BasicEventDefinition__Group__0__Impl rule__BasicEventDefinition__Group__1
+            {
+            pushFollow(FOLLOW_14);
+            rule__BasicEventDefinition__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__0"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__0__Impl"
+    // InternalCftLanguage.g:1267:1: rule__BasicEventDefinition__Group__0__Impl : ( ( rule__BasicEventDefinition__NameAssignment_0 ) ) ;
+    public final void rule__BasicEventDefinition__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1271:1: ( ( ( rule__BasicEventDefinition__NameAssignment_0 ) ) )
+            // InternalCftLanguage.g:1272:1: ( ( rule__BasicEventDefinition__NameAssignment_0 ) )
+            {
+            // InternalCftLanguage.g:1272:1: ( ( rule__BasicEventDefinition__NameAssignment_0 ) )
+            // InternalCftLanguage.g:1273:2: ( rule__BasicEventDefinition__NameAssignment_0 )
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getNameAssignment_0()); 
+            // InternalCftLanguage.g:1274:2: ( rule__BasicEventDefinition__NameAssignment_0 )
+            // InternalCftLanguage.g:1274:3: rule__BasicEventDefinition__NameAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__NameAssignment_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getBasicEventDefinitionAccess().getNameAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__0__Impl"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__1"
+    // InternalCftLanguage.g:1282:1: rule__BasicEventDefinition__Group__1 : rule__BasicEventDefinition__Group__1__Impl rule__BasicEventDefinition__Group__2 ;
+    public final void rule__BasicEventDefinition__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1286:1: ( rule__BasicEventDefinition__Group__1__Impl rule__BasicEventDefinition__Group__2 )
+            // InternalCftLanguage.g:1287:2: rule__BasicEventDefinition__Group__1__Impl rule__BasicEventDefinition__Group__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__BasicEventDefinition__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__1"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__1__Impl"
+    // InternalCftLanguage.g:1294:1: rule__BasicEventDefinition__Group__1__Impl : ( 'lambda' ) ;
+    public final void rule__BasicEventDefinition__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1298:1: ( ( 'lambda' ) )
+            // InternalCftLanguage.g:1299:1: ( 'lambda' )
+            {
+            // InternalCftLanguage.g:1299:1: ( 'lambda' )
+            // InternalCftLanguage.g:1300:2: 'lambda'
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getLambdaKeyword_1()); 
+            match(input,21,FOLLOW_2); 
+             after(grammarAccess.getBasicEventDefinitionAccess().getLambdaKeyword_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__1__Impl"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__2"
+    // InternalCftLanguage.g:1309:1: rule__BasicEventDefinition__Group__2 : rule__BasicEventDefinition__Group__2__Impl rule__BasicEventDefinition__Group__3 ;
+    public final void rule__BasicEventDefinition__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1313:1: ( rule__BasicEventDefinition__Group__2__Impl rule__BasicEventDefinition__Group__3 )
+            // InternalCftLanguage.g:1314:2: rule__BasicEventDefinition__Group__2__Impl rule__BasicEventDefinition__Group__3
+            {
+            pushFollow(FOLLOW_16);
+            rule__BasicEventDefinition__Group__2__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__Group__3();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__2"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__2__Impl"
+    // InternalCftLanguage.g:1321:1: rule__BasicEventDefinition__Group__2__Impl : ( '=' ) ;
+    public final void rule__BasicEventDefinition__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1325:1: ( ( '=' ) )
+            // InternalCftLanguage.g:1326:1: ( '=' )
+            {
+            // InternalCftLanguage.g:1326:1: ( '=' )
+            // InternalCftLanguage.g:1327:2: '='
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getEqualsSignKeyword_2()); 
+            match(input,22,FOLLOW_2); 
+             after(grammarAccess.getBasicEventDefinitionAccess().getEqualsSignKeyword_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__2__Impl"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__3"
+    // InternalCftLanguage.g:1336:1: rule__BasicEventDefinition__Group__3 : rule__BasicEventDefinition__Group__3__Impl ;
+    public final void rule__BasicEventDefinition__Group__3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1340:1: ( rule__BasicEventDefinition__Group__3__Impl )
+            // InternalCftLanguage.g:1341:2: rule__BasicEventDefinition__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__Group__3__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__3"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__Group__3__Impl"
+    // InternalCftLanguage.g:1347:1: rule__BasicEventDefinition__Group__3__Impl : ( ( rule__BasicEventDefinition__RateAssignment_3 ) ) ;
+    public final void rule__BasicEventDefinition__Group__3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1351:1: ( ( ( rule__BasicEventDefinition__RateAssignment_3 ) ) )
+            // InternalCftLanguage.g:1352:1: ( ( rule__BasicEventDefinition__RateAssignment_3 ) )
+            {
+            // InternalCftLanguage.g:1352:1: ( ( rule__BasicEventDefinition__RateAssignment_3 ) )
+            // InternalCftLanguage.g:1353:2: ( rule__BasicEventDefinition__RateAssignment_3 )
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getRateAssignment_3()); 
+            // InternalCftLanguage.g:1354:2: ( rule__BasicEventDefinition__RateAssignment_3 )
+            // InternalCftLanguage.g:1354:3: rule__BasicEventDefinition__RateAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__BasicEventDefinition__RateAssignment_3();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getBasicEventDefinitionAccess().getRateAssignment_3()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__Group__3__Impl"
+
+
+    // $ANTLR start "rule__AndGate__Group__0"
+    // InternalCftLanguage.g:1363:1: rule__AndGate__Group__0 : rule__AndGate__Group__0__Impl rule__AndGate__Group__1 ;
+    public final void rule__AndGate__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1367:1: ( rule__AndGate__Group__0__Impl rule__AndGate__Group__1 )
+            // InternalCftLanguage.g:1368:2: rule__AndGate__Group__0__Impl rule__AndGate__Group__1
+            {
+            pushFollow(FOLLOW_17);
+            rule__AndGate__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__AndGate__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__Group__0"
+
+
+    // $ANTLR start "rule__AndGate__Group__0__Impl"
+    // InternalCftLanguage.g:1375:1: rule__AndGate__Group__0__Impl : ( ( rule__AndGate__NameAssignment_0 ) ) ;
+    public final void rule__AndGate__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1379:1: ( ( ( rule__AndGate__NameAssignment_0 ) ) )
+            // InternalCftLanguage.g:1380:1: ( ( rule__AndGate__NameAssignment_0 ) )
+            {
+            // InternalCftLanguage.g:1380:1: ( ( rule__AndGate__NameAssignment_0 ) )
+            // InternalCftLanguage.g:1381:2: ( rule__AndGate__NameAssignment_0 )
+            {
+             before(grammarAccess.getAndGateAccess().getNameAssignment_0()); 
+            // InternalCftLanguage.g:1382:2: ( rule__AndGate__NameAssignment_0 )
+            // InternalCftLanguage.g:1382:3: rule__AndGate__NameAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__AndGate__NameAssignment_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getAndGateAccess().getNameAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__Group__0__Impl"
+
+
+    // $ANTLR start "rule__AndGate__Group__1"
+    // InternalCftLanguage.g:1390:1: rule__AndGate__Group__1 : rule__AndGate__Group__1__Impl rule__AndGate__Group__2 ;
+    public final void rule__AndGate__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1394:1: ( rule__AndGate__Group__1__Impl rule__AndGate__Group__2 )
+            // InternalCftLanguage.g:1395:2: rule__AndGate__Group__1__Impl rule__AndGate__Group__2
+            {
+            pushFollow(FOLLOW_3);
+            rule__AndGate__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__AndGate__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__Group__1"
+
+
+    // $ANTLR start "rule__AndGate__Group__1__Impl"
+    // InternalCftLanguage.g:1402:1: rule__AndGate__Group__1__Impl : ( 'and' ) ;
+    public final void rule__AndGate__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1406:1: ( ( 'and' ) )
+            // InternalCftLanguage.g:1407:1: ( 'and' )
+            {
+            // InternalCftLanguage.g:1407:1: ( 'and' )
+            // InternalCftLanguage.g:1408:2: 'and'
+            {
+             before(grammarAccess.getAndGateAccess().getAndKeyword_1()); 
+            match(input,23,FOLLOW_2); 
+             after(grammarAccess.getAndGateAccess().getAndKeyword_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__Group__1__Impl"
+
+
+    // $ANTLR start "rule__AndGate__Group__2"
+    // InternalCftLanguage.g:1417:1: rule__AndGate__Group__2 : rule__AndGate__Group__2__Impl ;
+    public final void rule__AndGate__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1421:1: ( rule__AndGate__Group__2__Impl )
+            // InternalCftLanguage.g:1422:2: rule__AndGate__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__AndGate__Group__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__Group__2"
+
+
+    // $ANTLR start "rule__AndGate__Group__2__Impl"
+    // InternalCftLanguage.g:1428:1: rule__AndGate__Group__2__Impl : ( ( rule__AndGate__InputEventsAssignment_2 )* ) ;
+    public final void rule__AndGate__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1432:1: ( ( ( rule__AndGate__InputEventsAssignment_2 )* ) )
+            // InternalCftLanguage.g:1433:1: ( ( rule__AndGate__InputEventsAssignment_2 )* )
+            {
+            // InternalCftLanguage.g:1433:1: ( ( rule__AndGate__InputEventsAssignment_2 )* )
+            // InternalCftLanguage.g:1434:2: ( rule__AndGate__InputEventsAssignment_2 )*
+            {
+             before(grammarAccess.getAndGateAccess().getInputEventsAssignment_2()); 
+            // InternalCftLanguage.g:1435:2: ( rule__AndGate__InputEventsAssignment_2 )*
+            loop14:
+            do {
+                int alt14=2;
+                int LA14_0 = input.LA(1);
+
+                if ( (LA14_0==RULE_ID) ) {
+                    alt14=1;
+                }
+
+
+                switch (alt14) {
+                case 1 :
+                    // InternalCftLanguage.g:1435:3: rule__AndGate__InputEventsAssignment_2
+                    {
+                    pushFollow(FOLLOW_11);
+                    rule__AndGate__InputEventsAssignment_2();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop14;
+                }
+            } while (true);
+
+             after(grammarAccess.getAndGateAccess().getInputEventsAssignment_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__Group__2__Impl"
+
+
+    // $ANTLR start "rule__OrGate__Group__0"
+    // InternalCftLanguage.g:1444:1: rule__OrGate__Group__0 : rule__OrGate__Group__0__Impl rule__OrGate__Group__1 ;
+    public final void rule__OrGate__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1448:1: ( rule__OrGate__Group__0__Impl rule__OrGate__Group__1 )
+            // InternalCftLanguage.g:1449:2: rule__OrGate__Group__0__Impl rule__OrGate__Group__1
+            {
+            pushFollow(FOLLOW_18);
+            rule__OrGate__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__OrGate__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__Group__0"
+
+
+    // $ANTLR start "rule__OrGate__Group__0__Impl"
+    // InternalCftLanguage.g:1456:1: rule__OrGate__Group__0__Impl : ( ( rule__OrGate__NameAssignment_0 ) ) ;
+    public final void rule__OrGate__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1460:1: ( ( ( rule__OrGate__NameAssignment_0 ) ) )
+            // InternalCftLanguage.g:1461:1: ( ( rule__OrGate__NameAssignment_0 ) )
+            {
+            // InternalCftLanguage.g:1461:1: ( ( rule__OrGate__NameAssignment_0 ) )
+            // InternalCftLanguage.g:1462:2: ( rule__OrGate__NameAssignment_0 )
+            {
+             before(grammarAccess.getOrGateAccess().getNameAssignment_0()); 
+            // InternalCftLanguage.g:1463:2: ( rule__OrGate__NameAssignment_0 )
+            // InternalCftLanguage.g:1463:3: rule__OrGate__NameAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__OrGate__NameAssignment_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getOrGateAccess().getNameAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__Group__0__Impl"
+
+
+    // $ANTLR start "rule__OrGate__Group__1"
+    // InternalCftLanguage.g:1471:1: rule__OrGate__Group__1 : rule__OrGate__Group__1__Impl rule__OrGate__Group__2 ;
+    public final void rule__OrGate__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1475:1: ( rule__OrGate__Group__1__Impl rule__OrGate__Group__2 )
+            // InternalCftLanguage.g:1476:2: rule__OrGate__Group__1__Impl rule__OrGate__Group__2
+            {
+            pushFollow(FOLLOW_3);
+            rule__OrGate__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__OrGate__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__Group__1"
+
+
+    // $ANTLR start "rule__OrGate__Group__1__Impl"
+    // InternalCftLanguage.g:1483:1: rule__OrGate__Group__1__Impl : ( 'or' ) ;
+    public final void rule__OrGate__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1487:1: ( ( 'or' ) )
+            // InternalCftLanguage.g:1488:1: ( 'or' )
+            {
+            // InternalCftLanguage.g:1488:1: ( 'or' )
+            // InternalCftLanguage.g:1489:2: 'or'
+            {
+             before(grammarAccess.getOrGateAccess().getOrKeyword_1()); 
+            match(input,24,FOLLOW_2); 
+             after(grammarAccess.getOrGateAccess().getOrKeyword_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__Group__1__Impl"
+
+
+    // $ANTLR start "rule__OrGate__Group__2"
+    // InternalCftLanguage.g:1498:1: rule__OrGate__Group__2 : rule__OrGate__Group__2__Impl ;
+    public final void rule__OrGate__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1502:1: ( rule__OrGate__Group__2__Impl )
+            // InternalCftLanguage.g:1503:2: rule__OrGate__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OrGate__Group__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__Group__2"
+
+
+    // $ANTLR start "rule__OrGate__Group__2__Impl"
+    // InternalCftLanguage.g:1509:1: rule__OrGate__Group__2__Impl : ( ( rule__OrGate__InputEventsAssignment_2 )* ) ;
+    public final void rule__OrGate__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1513:1: ( ( ( rule__OrGate__InputEventsAssignment_2 )* ) )
+            // InternalCftLanguage.g:1514:1: ( ( rule__OrGate__InputEventsAssignment_2 )* )
+            {
+            // InternalCftLanguage.g:1514:1: ( ( rule__OrGate__InputEventsAssignment_2 )* )
+            // InternalCftLanguage.g:1515:2: ( rule__OrGate__InputEventsAssignment_2 )*
+            {
+             before(grammarAccess.getOrGateAccess().getInputEventsAssignment_2()); 
+            // InternalCftLanguage.g:1516:2: ( rule__OrGate__InputEventsAssignment_2 )*
+            loop15:
+            do {
+                int alt15=2;
+                int LA15_0 = input.LA(1);
+
+                if ( (LA15_0==RULE_ID) ) {
+                    alt15=1;
+                }
+
+
+                switch (alt15) {
+                case 1 :
+                    // InternalCftLanguage.g:1516:3: rule__OrGate__InputEventsAssignment_2
+                    {
+                    pushFollow(FOLLOW_11);
+                    rule__OrGate__InputEventsAssignment_2();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop15;
+                }
+            } while (true);
+
+             after(grammarAccess.getOrGateAccess().getInputEventsAssignment_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__Group__2__Impl"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__0"
+    // InternalCftLanguage.g:1525:1: rule__TransformationDefinition__Group__0 : rule__TransformationDefinition__Group__0__Impl rule__TransformationDefinition__Group__1 ;
+    public final void rule__TransformationDefinition__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1529:1: ( rule__TransformationDefinition__Group__0__Impl rule__TransformationDefinition__Group__1 )
+            // InternalCftLanguage.g:1530:2: rule__TransformationDefinition__Group__0__Impl rule__TransformationDefinition__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__TransformationDefinition__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__0"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__0__Impl"
+    // InternalCftLanguage.g:1537:1: rule__TransformationDefinition__Group__0__Impl : ( 'transformation' ) ;
+    public final void rule__TransformationDefinition__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1541:1: ( ( 'transformation' ) )
+            // InternalCftLanguage.g:1542:1: ( 'transformation' )
+            {
+            // InternalCftLanguage.g:1542:1: ( 'transformation' )
+            // InternalCftLanguage.g:1543:2: 'transformation'
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getTransformationKeyword_0()); 
+            match(input,25,FOLLOW_2); 
+             after(grammarAccess.getTransformationDefinitionAccess().getTransformationKeyword_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__0__Impl"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__1"
+    // InternalCftLanguage.g:1552:1: rule__TransformationDefinition__Group__1 : rule__TransformationDefinition__Group__1__Impl rule__TransformationDefinition__Group__2 ;
+    public final void rule__TransformationDefinition__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1556:1: ( rule__TransformationDefinition__Group__1__Impl rule__TransformationDefinition__Group__2 )
+            // InternalCftLanguage.g:1557:2: rule__TransformationDefinition__Group__1__Impl rule__TransformationDefinition__Group__2
+            {
+            pushFollow(FOLLOW_8);
+            rule__TransformationDefinition__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__1"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__1__Impl"
+    // InternalCftLanguage.g:1564:1: rule__TransformationDefinition__Group__1__Impl : ( ( rule__TransformationDefinition__NameAssignment_1 ) ) ;
+    public final void rule__TransformationDefinition__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1568:1: ( ( ( rule__TransformationDefinition__NameAssignment_1 ) ) )
+            // InternalCftLanguage.g:1569:1: ( ( rule__TransformationDefinition__NameAssignment_1 ) )
+            {
+            // InternalCftLanguage.g:1569:1: ( ( rule__TransformationDefinition__NameAssignment_1 ) )
+            // InternalCftLanguage.g:1570:2: ( rule__TransformationDefinition__NameAssignment_1 )
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getNameAssignment_1()); 
+            // InternalCftLanguage.g:1571:2: ( rule__TransformationDefinition__NameAssignment_1 )
+            // InternalCftLanguage.g:1571:3: rule__TransformationDefinition__NameAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__NameAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getTransformationDefinitionAccess().getNameAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__1__Impl"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__2"
+    // InternalCftLanguage.g:1579:1: rule__TransformationDefinition__Group__2 : rule__TransformationDefinition__Group__2__Impl rule__TransformationDefinition__Group__3 ;
+    public final void rule__TransformationDefinition__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1583:1: ( rule__TransformationDefinition__Group__2__Impl rule__TransformationDefinition__Group__3 )
+            // InternalCftLanguage.g:1584:2: rule__TransformationDefinition__Group__2__Impl rule__TransformationDefinition__Group__3
+            {
+            pushFollow(FOLLOW_19);
+            rule__TransformationDefinition__Group__2__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__Group__3();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__2"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__2__Impl"
+    // InternalCftLanguage.g:1591:1: rule__TransformationDefinition__Group__2__Impl : ( '{' ) ;
+    public final void rule__TransformationDefinition__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1595:1: ( ( '{' ) )
+            // InternalCftLanguage.g:1596:1: ( '{' )
+            {
+            // InternalCftLanguage.g:1596:1: ( '{' )
+            // InternalCftLanguage.g:1597:2: '{'
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getLeftCurlyBracketKeyword_2()); 
+            match(input,17,FOLLOW_2); 
+             after(grammarAccess.getTransformationDefinitionAccess().getLeftCurlyBracketKeyword_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__2__Impl"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__3"
+    // InternalCftLanguage.g:1606:1: rule__TransformationDefinition__Group__3 : rule__TransformationDefinition__Group__3__Impl rule__TransformationDefinition__Group__4 ;
+    public final void rule__TransformationDefinition__Group__3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1610:1: ( rule__TransformationDefinition__Group__3__Impl rule__TransformationDefinition__Group__4 )
+            // InternalCftLanguage.g:1611:2: rule__TransformationDefinition__Group__3__Impl rule__TransformationDefinition__Group__4
+            {
+            pushFollow(FOLLOW_19);
+            rule__TransformationDefinition__Group__3__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__Group__4();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__3"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__3__Impl"
+    // InternalCftLanguage.g:1618:1: rule__TransformationDefinition__Group__3__Impl : ( ( rule__TransformationDefinition__MappingDefinitionsAssignment_3 )* ) ;
+    public final void rule__TransformationDefinition__Group__3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1622:1: ( ( ( rule__TransformationDefinition__MappingDefinitionsAssignment_3 )* ) )
+            // InternalCftLanguage.g:1623:1: ( ( rule__TransformationDefinition__MappingDefinitionsAssignment_3 )* )
+            {
+            // InternalCftLanguage.g:1623:1: ( ( rule__TransformationDefinition__MappingDefinitionsAssignment_3 )* )
+            // InternalCftLanguage.g:1624:2: ( rule__TransformationDefinition__MappingDefinitionsAssignment_3 )*
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getMappingDefinitionsAssignment_3()); 
+            // InternalCftLanguage.g:1625:2: ( rule__TransformationDefinition__MappingDefinitionsAssignment_3 )*
+            loop16:
+            do {
+                int alt16=2;
+                int LA16_0 = input.LA(1);
+
+                if ( (LA16_0==26||LA16_0==36) ) {
+                    alt16=1;
+                }
+
+
+                switch (alt16) {
+                case 1 :
+                    // InternalCftLanguage.g:1625:3: rule__TransformationDefinition__MappingDefinitionsAssignment_3
+                    {
+                    pushFollow(FOLLOW_20);
+                    rule__TransformationDefinition__MappingDefinitionsAssignment_3();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop16;
+                }
+            } while (true);
+
+             after(grammarAccess.getTransformationDefinitionAccess().getMappingDefinitionsAssignment_3()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__3__Impl"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__4"
+    // InternalCftLanguage.g:1633:1: rule__TransformationDefinition__Group__4 : rule__TransformationDefinition__Group__4__Impl ;
+    public final void rule__TransformationDefinition__Group__4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1637:1: ( rule__TransformationDefinition__Group__4__Impl )
+            // InternalCftLanguage.g:1638:2: rule__TransformationDefinition__Group__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__TransformationDefinition__Group__4__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__4"
+
+
+    // $ANTLR start "rule__TransformationDefinition__Group__4__Impl"
+    // InternalCftLanguage.g:1644:1: rule__TransformationDefinition__Group__4__Impl : ( '}' ) ;
+    public final void rule__TransformationDefinition__Group__4__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1648:1: ( ( '}' ) )
+            // InternalCftLanguage.g:1649:1: ( '}' )
+            {
+            // InternalCftLanguage.g:1649:1: ( '}' )
+            // InternalCftLanguage.g:1650:2: '}'
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getRightCurlyBracketKeyword_4()); 
+            match(input,18,FOLLOW_2); 
+             after(grammarAccess.getTransformationDefinitionAccess().getRightCurlyBracketKeyword_4()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__Group__4__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__0"
+    // InternalCftLanguage.g:1660:1: rule__MappingDefinition__Group__0 : rule__MappingDefinition__Group__0__Impl rule__MappingDefinition__Group__1 ;
+    public final void rule__MappingDefinition__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1664:1: ( rule__MappingDefinition__Group__0__Impl rule__MappingDefinition__Group__1 )
+            // InternalCftLanguage.g:1665:2: rule__MappingDefinition__Group__0__Impl rule__MappingDefinition__Group__1
+            {
+            pushFollow(FOLLOW_21);
+            rule__MappingDefinition__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__0"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__0__Impl"
+    // InternalCftLanguage.g:1672:1: rule__MappingDefinition__Group__0__Impl : ( ( rule__MappingDefinition__TopLevelAssignment_0 )? ) ;
+    public final void rule__MappingDefinition__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1676:1: ( ( ( rule__MappingDefinition__TopLevelAssignment_0 )? ) )
+            // InternalCftLanguage.g:1677:1: ( ( rule__MappingDefinition__TopLevelAssignment_0 )? )
+            {
+            // InternalCftLanguage.g:1677:1: ( ( rule__MappingDefinition__TopLevelAssignment_0 )? )
+            // InternalCftLanguage.g:1678:2: ( rule__MappingDefinition__TopLevelAssignment_0 )?
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getTopLevelAssignment_0()); 
+            // InternalCftLanguage.g:1679:2: ( rule__MappingDefinition__TopLevelAssignment_0 )?
+            int alt17=2;
+            int LA17_0 = input.LA(1);
+
+            if ( (LA17_0==36) ) {
+                alt17=1;
+            }
+            switch (alt17) {
+                case 1 :
+                    // InternalCftLanguage.g:1679:3: rule__MappingDefinition__TopLevelAssignment_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__MappingDefinition__TopLevelAssignment_0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getTopLevelAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__0__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__1"
+    // InternalCftLanguage.g:1687:1: rule__MappingDefinition__Group__1 : rule__MappingDefinition__Group__1__Impl rule__MappingDefinition__Group__2 ;
+    public final void rule__MappingDefinition__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1691:1: ( rule__MappingDefinition__Group__1__Impl rule__MappingDefinition__Group__2 )
+            // InternalCftLanguage.g:1692:2: rule__MappingDefinition__Group__1__Impl rule__MappingDefinition__Group__2
+            {
+            pushFollow(FOLLOW_3);
+            rule__MappingDefinition__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__1"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__1__Impl"
+    // InternalCftLanguage.g:1699:1: rule__MappingDefinition__Group__1__Impl : ( 'mapping' ) ;
+    public final void rule__MappingDefinition__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1703:1: ( ( 'mapping' ) )
+            // InternalCftLanguage.g:1704:1: ( 'mapping' )
+            {
+            // InternalCftLanguage.g:1704:1: ( 'mapping' )
+            // InternalCftLanguage.g:1705:2: 'mapping'
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getMappingKeyword_1()); 
+            match(input,26,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getMappingKeyword_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__1__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__2"
+    // InternalCftLanguage.g:1714:1: rule__MappingDefinition__Group__2 : rule__MappingDefinition__Group__2__Impl rule__MappingDefinition__Group__3 ;
+    public final void rule__MappingDefinition__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1718:1: ( rule__MappingDefinition__Group__2__Impl rule__MappingDefinition__Group__3 )
+            // InternalCftLanguage.g:1719:2: rule__MappingDefinition__Group__2__Impl rule__MappingDefinition__Group__3
+            {
+            pushFollow(FOLLOW_22);
+            rule__MappingDefinition__Group__2__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__3();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__2"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__2__Impl"
+    // InternalCftLanguage.g:1726:1: rule__MappingDefinition__Group__2__Impl : ( ( rule__MappingDefinition__PatternAssignment_2 ) ) ;
+    public final void rule__MappingDefinition__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1730:1: ( ( ( rule__MappingDefinition__PatternAssignment_2 ) ) )
+            // InternalCftLanguage.g:1731:1: ( ( rule__MappingDefinition__PatternAssignment_2 ) )
+            {
+            // InternalCftLanguage.g:1731:1: ( ( rule__MappingDefinition__PatternAssignment_2 ) )
+            // InternalCftLanguage.g:1732:2: ( rule__MappingDefinition__PatternAssignment_2 )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getPatternAssignment_2()); 
+            // InternalCftLanguage.g:1733:2: ( rule__MappingDefinition__PatternAssignment_2 )
+            // InternalCftLanguage.g:1733:3: rule__MappingDefinition__PatternAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__PatternAssignment_2();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getPatternAssignment_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__2__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__3"
+    // InternalCftLanguage.g:1741:1: rule__MappingDefinition__Group__3 : rule__MappingDefinition__Group__3__Impl rule__MappingDefinition__Group__4 ;
+    public final void rule__MappingDefinition__Group__3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1745:1: ( rule__MappingDefinition__Group__3__Impl rule__MappingDefinition__Group__4 )
+            // InternalCftLanguage.g:1746:2: rule__MappingDefinition__Group__3__Impl rule__MappingDefinition__Group__4
+            {
+            pushFollow(FOLLOW_3);
+            rule__MappingDefinition__Group__3__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__4();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__3"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__3__Impl"
+    // InternalCftLanguage.g:1753:1: rule__MappingDefinition__Group__3__Impl : ( '(' ) ;
+    public final void rule__MappingDefinition__Group__3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1757:1: ( ( '(' ) )
+            // InternalCftLanguage.g:1758:1: ( '(' )
+            {
+            // InternalCftLanguage.g:1758:1: ( '(' )
+            // InternalCftLanguage.g:1759:2: '('
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getLeftParenthesisKeyword_3()); 
+            match(input,27,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getLeftParenthesisKeyword_3()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__3__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__4"
+    // InternalCftLanguage.g:1768:1: rule__MappingDefinition__Group__4 : rule__MappingDefinition__Group__4__Impl rule__MappingDefinition__Group__5 ;
+    public final void rule__MappingDefinition__Group__4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1772:1: ( rule__MappingDefinition__Group__4__Impl rule__MappingDefinition__Group__5 )
+            // InternalCftLanguage.g:1773:2: rule__MappingDefinition__Group__4__Impl rule__MappingDefinition__Group__5
+            {
+            pushFollow(FOLLOW_23);
+            rule__MappingDefinition__Group__4__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__5();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__4"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__4__Impl"
+    // InternalCftLanguage.g:1780:1: rule__MappingDefinition__Group__4__Impl : ( ( rule__MappingDefinition__ParametersAssignment_4 ) ) ;
+    public final void rule__MappingDefinition__Group__4__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1784:1: ( ( ( rule__MappingDefinition__ParametersAssignment_4 ) ) )
+            // InternalCftLanguage.g:1785:1: ( ( rule__MappingDefinition__ParametersAssignment_4 ) )
+            {
+            // InternalCftLanguage.g:1785:1: ( ( rule__MappingDefinition__ParametersAssignment_4 ) )
+            // InternalCftLanguage.g:1786:2: ( rule__MappingDefinition__ParametersAssignment_4 )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getParametersAssignment_4()); 
+            // InternalCftLanguage.g:1787:2: ( rule__MappingDefinition__ParametersAssignment_4 )
+            // InternalCftLanguage.g:1787:3: rule__MappingDefinition__ParametersAssignment_4
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__ParametersAssignment_4();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getParametersAssignment_4()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__4__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__5"
+    // InternalCftLanguage.g:1795:1: rule__MappingDefinition__Group__5 : rule__MappingDefinition__Group__5__Impl rule__MappingDefinition__Group__6 ;
+    public final void rule__MappingDefinition__Group__5() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1799:1: ( rule__MappingDefinition__Group__5__Impl rule__MappingDefinition__Group__6 )
+            // InternalCftLanguage.g:1800:2: rule__MappingDefinition__Group__5__Impl rule__MappingDefinition__Group__6
+            {
+            pushFollow(FOLLOW_23);
+            rule__MappingDefinition__Group__5__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__6();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__5"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__5__Impl"
+    // InternalCftLanguage.g:1807:1: rule__MappingDefinition__Group__5__Impl : ( ( rule__MappingDefinition__Group_5__0 )* ) ;
+    public final void rule__MappingDefinition__Group__5__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1811:1: ( ( ( rule__MappingDefinition__Group_5__0 )* ) )
+            // InternalCftLanguage.g:1812:1: ( ( rule__MappingDefinition__Group_5__0 )* )
+            {
+            // InternalCftLanguage.g:1812:1: ( ( rule__MappingDefinition__Group_5__0 )* )
+            // InternalCftLanguage.g:1813:2: ( rule__MappingDefinition__Group_5__0 )*
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getGroup_5()); 
+            // InternalCftLanguage.g:1814:2: ( rule__MappingDefinition__Group_5__0 )*
+            loop18:
+            do {
+                int alt18=2;
+                int LA18_0 = input.LA(1);
+
+                if ( (LA18_0==29) ) {
+                    alt18=1;
+                }
+
+
+                switch (alt18) {
+                case 1 :
+                    // InternalCftLanguage.g:1814:3: rule__MappingDefinition__Group_5__0
+                    {
+                    pushFollow(FOLLOW_24);
+                    rule__MappingDefinition__Group_5__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop18;
+                }
+            } while (true);
+
+             after(grammarAccess.getMappingDefinitionAccess().getGroup_5()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__5__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__6"
+    // InternalCftLanguage.g:1822:1: rule__MappingDefinition__Group__6 : rule__MappingDefinition__Group__6__Impl rule__MappingDefinition__Group__7 ;
+    public final void rule__MappingDefinition__Group__6() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1826:1: ( rule__MappingDefinition__Group__6__Impl rule__MappingDefinition__Group__7 )
+            // InternalCftLanguage.g:1827:2: rule__MappingDefinition__Group__6__Impl rule__MappingDefinition__Group__7
+            {
+            pushFollow(FOLLOW_25);
+            rule__MappingDefinition__Group__6__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__7();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__6"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__6__Impl"
+    // InternalCftLanguage.g:1834:1: rule__MappingDefinition__Group__6__Impl : ( ')' ) ;
+    public final void rule__MappingDefinition__Group__6__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1838:1: ( ( ')' ) )
+            // InternalCftLanguage.g:1839:1: ( ')' )
+            {
+            // InternalCftLanguage.g:1839:1: ( ')' )
+            // InternalCftLanguage.g:1840:2: ')'
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getRightParenthesisKeyword_6()); 
+            match(input,28,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getRightParenthesisKeyword_6()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__6__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__7"
+    // InternalCftLanguage.g:1849:1: rule__MappingDefinition__Group__7 : rule__MappingDefinition__Group__7__Impl rule__MappingDefinition__Group__8 ;
+    public final void rule__MappingDefinition__Group__7() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1853:1: ( rule__MappingDefinition__Group__7__Impl rule__MappingDefinition__Group__8 )
+            // InternalCftLanguage.g:1854:2: rule__MappingDefinition__Group__7__Impl rule__MappingDefinition__Group__8
+            {
+            pushFollow(FOLLOW_25);
+            rule__MappingDefinition__Group__7__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__8();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__7"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__7__Impl"
+    // InternalCftLanguage.g:1861:1: rule__MappingDefinition__Group__7__Impl : ( ( rule__MappingDefinition__ComponentInstanceAssignment_7 )? ) ;
+    public final void rule__MappingDefinition__Group__7__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1865:1: ( ( ( rule__MappingDefinition__ComponentInstanceAssignment_7 )? ) )
+            // InternalCftLanguage.g:1866:1: ( ( rule__MappingDefinition__ComponentInstanceAssignment_7 )? )
+            {
+            // InternalCftLanguage.g:1866:1: ( ( rule__MappingDefinition__ComponentInstanceAssignment_7 )? )
+            // InternalCftLanguage.g:1867:2: ( rule__MappingDefinition__ComponentInstanceAssignment_7 )?
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getComponentInstanceAssignment_7()); 
+            // InternalCftLanguage.g:1868:2: ( rule__MappingDefinition__ComponentInstanceAssignment_7 )?
+            int alt19=2;
+            int LA19_0 = input.LA(1);
+
+            if ( (LA19_0==33) ) {
+                alt19=1;
+            }
+            switch (alt19) {
+                case 1 :
+                    // InternalCftLanguage.g:1868:3: rule__MappingDefinition__ComponentInstanceAssignment_7
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__MappingDefinition__ComponentInstanceAssignment_7();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getComponentInstanceAssignment_7()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__7__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__8"
+    // InternalCftLanguage.g:1876:1: rule__MappingDefinition__Group__8 : rule__MappingDefinition__Group__8__Impl ;
+    public final void rule__MappingDefinition__Group__8() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1880:1: ( rule__MappingDefinition__Group__8__Impl )
+            // InternalCftLanguage.g:1881:2: rule__MappingDefinition__Group__8__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group__8__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__8"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group__8__Impl"
+    // InternalCftLanguage.g:1887:1: rule__MappingDefinition__Group__8__Impl : ( ( rule__MappingDefinition__Group_8__0 )? ) ;
+    public final void rule__MappingDefinition__Group__8__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1891:1: ( ( ( rule__MappingDefinition__Group_8__0 )? ) )
+            // InternalCftLanguage.g:1892:1: ( ( rule__MappingDefinition__Group_8__0 )? )
+            {
+            // InternalCftLanguage.g:1892:1: ( ( rule__MappingDefinition__Group_8__0 )? )
+            // InternalCftLanguage.g:1893:2: ( rule__MappingDefinition__Group_8__0 )?
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getGroup_8()); 
+            // InternalCftLanguage.g:1894:2: ( rule__MappingDefinition__Group_8__0 )?
+            int alt20=2;
+            int LA20_0 = input.LA(1);
+
+            if ( (LA20_0==17) ) {
+                alt20=1;
+            }
+            switch (alt20) {
+                case 1 :
+                    // InternalCftLanguage.g:1894:3: rule__MappingDefinition__Group_8__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__MappingDefinition__Group_8__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getGroup_8()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group__8__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_5__0"
+    // InternalCftLanguage.g:1903:1: rule__MappingDefinition__Group_5__0 : rule__MappingDefinition__Group_5__0__Impl rule__MappingDefinition__Group_5__1 ;
+    public final void rule__MappingDefinition__Group_5__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1907:1: ( rule__MappingDefinition__Group_5__0__Impl rule__MappingDefinition__Group_5__1 )
+            // InternalCftLanguage.g:1908:2: rule__MappingDefinition__Group_5__0__Impl rule__MappingDefinition__Group_5__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__MappingDefinition__Group_5__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_5__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_5__0"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_5__0__Impl"
+    // InternalCftLanguage.g:1915:1: rule__MappingDefinition__Group_5__0__Impl : ( ',' ) ;
+    public final void rule__MappingDefinition__Group_5__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1919:1: ( ( ',' ) )
+            // InternalCftLanguage.g:1920:1: ( ',' )
+            {
+            // InternalCftLanguage.g:1920:1: ( ',' )
+            // InternalCftLanguage.g:1921:2: ','
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getCommaKeyword_5_0()); 
+            match(input,29,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getCommaKeyword_5_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_5__0__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_5__1"
+    // InternalCftLanguage.g:1930:1: rule__MappingDefinition__Group_5__1 : rule__MappingDefinition__Group_5__1__Impl ;
+    public final void rule__MappingDefinition__Group_5__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1934:1: ( rule__MappingDefinition__Group_5__1__Impl )
+            // InternalCftLanguage.g:1935:2: rule__MappingDefinition__Group_5__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_5__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_5__1"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_5__1__Impl"
+    // InternalCftLanguage.g:1941:1: rule__MappingDefinition__Group_5__1__Impl : ( ( rule__MappingDefinition__ParametersAssignment_5_1 ) ) ;
+    public final void rule__MappingDefinition__Group_5__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1945:1: ( ( ( rule__MappingDefinition__ParametersAssignment_5_1 ) ) )
+            // InternalCftLanguage.g:1946:1: ( ( rule__MappingDefinition__ParametersAssignment_5_1 ) )
+            {
+            // InternalCftLanguage.g:1946:1: ( ( rule__MappingDefinition__ParametersAssignment_5_1 ) )
+            // InternalCftLanguage.g:1947:2: ( rule__MappingDefinition__ParametersAssignment_5_1 )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getParametersAssignment_5_1()); 
+            // InternalCftLanguage.g:1948:2: ( rule__MappingDefinition__ParametersAssignment_5_1 )
+            // InternalCftLanguage.g:1948:3: rule__MappingDefinition__ParametersAssignment_5_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__ParametersAssignment_5_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getParametersAssignment_5_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_5__1__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8__0"
+    // InternalCftLanguage.g:1957:1: rule__MappingDefinition__Group_8__0 : rule__MappingDefinition__Group_8__0__Impl rule__MappingDefinition__Group_8__1 ;
+    public final void rule__MappingDefinition__Group_8__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1961:1: ( rule__MappingDefinition__Group_8__0__Impl rule__MappingDefinition__Group_8__1 )
+            // InternalCftLanguage.g:1962:2: rule__MappingDefinition__Group_8__0__Impl rule__MappingDefinition__Group_8__1
+            {
+            pushFollow(FOLLOW_26);
+            rule__MappingDefinition__Group_8__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_8__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8__0"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8__0__Impl"
+    // InternalCftLanguage.g:1969:1: rule__MappingDefinition__Group_8__0__Impl : ( '{' ) ;
+    public final void rule__MappingDefinition__Group_8__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1973:1: ( ( '{' ) )
+            // InternalCftLanguage.g:1974:1: ( '{' )
+            {
+            // InternalCftLanguage.g:1974:1: ( '{' )
+            // InternalCftLanguage.g:1975:2: '{'
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getLeftCurlyBracketKeyword_8_0()); 
+            match(input,17,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getLeftCurlyBracketKeyword_8_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8__0__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8__1"
+    // InternalCftLanguage.g:1984:1: rule__MappingDefinition__Group_8__1 : rule__MappingDefinition__Group_8__1__Impl rule__MappingDefinition__Group_8__2 ;
+    public final void rule__MappingDefinition__Group_8__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:1988:1: ( rule__MappingDefinition__Group_8__1__Impl rule__MappingDefinition__Group_8__2 )
+            // InternalCftLanguage.g:1989:2: rule__MappingDefinition__Group_8__1__Impl rule__MappingDefinition__Group_8__2
+            {
+            pushFollow(FOLLOW_26);
+            rule__MappingDefinition__Group_8__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_8__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8__1"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8__1__Impl"
+    // InternalCftLanguage.g:1996:1: rule__MappingDefinition__Group_8__1__Impl : ( ( rule__MappingDefinition__Group_8_1__0 )* ) ;
+    public final void rule__MappingDefinition__Group_8__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2000:1: ( ( ( rule__MappingDefinition__Group_8_1__0 )* ) )
+            // InternalCftLanguage.g:2001:1: ( ( rule__MappingDefinition__Group_8_1__0 )* )
+            {
+            // InternalCftLanguage.g:2001:1: ( ( rule__MappingDefinition__Group_8_1__0 )* )
+            // InternalCftLanguage.g:2002:2: ( rule__MappingDefinition__Group_8_1__0 )*
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getGroup_8_1()); 
+            // InternalCftLanguage.g:2003:2: ( rule__MappingDefinition__Group_8_1__0 )*
+            loop21:
+            do {
+                int alt21=2;
+                int LA21_0 = input.LA(1);
+
+                if ( (LA21_0==RULE_ID||LA21_0==30) ) {
+                    alt21=1;
+                }
+
+
+                switch (alt21) {
+                case 1 :
+                    // InternalCftLanguage.g:2003:3: rule__MappingDefinition__Group_8_1__0
+                    {
+                    pushFollow(FOLLOW_27);
+                    rule__MappingDefinition__Group_8_1__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop21;
+                }
+            } while (true);
+
+             after(grammarAccess.getMappingDefinitionAccess().getGroup_8_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8__1__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8__2"
+    // InternalCftLanguage.g:2011:1: rule__MappingDefinition__Group_8__2 : rule__MappingDefinition__Group_8__2__Impl ;
+    public final void rule__MappingDefinition__Group_8__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2015:1: ( rule__MappingDefinition__Group_8__2__Impl )
+            // InternalCftLanguage.g:2016:2: rule__MappingDefinition__Group_8__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_8__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8__2"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8__2__Impl"
+    // InternalCftLanguage.g:2022:1: rule__MappingDefinition__Group_8__2__Impl : ( '}' ) ;
+    public final void rule__MappingDefinition__Group_8__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2026:1: ( ( '}' ) )
+            // InternalCftLanguage.g:2027:1: ( '}' )
+            {
+            // InternalCftLanguage.g:2027:1: ( '}' )
+            // InternalCftLanguage.g:2028:2: '}'
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getRightCurlyBracketKeyword_8_2()); 
+            match(input,18,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getRightCurlyBracketKeyword_8_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8__2__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8_1__0"
+    // InternalCftLanguage.g:2038:1: rule__MappingDefinition__Group_8_1__0 : rule__MappingDefinition__Group_8_1__0__Impl rule__MappingDefinition__Group_8_1__1 ;
+    public final void rule__MappingDefinition__Group_8_1__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2042:1: ( rule__MappingDefinition__Group_8_1__0__Impl rule__MappingDefinition__Group_8_1__1 )
+            // InternalCftLanguage.g:2043:2: rule__MappingDefinition__Group_8_1__0__Impl rule__MappingDefinition__Group_8_1__1
+            {
+            pushFollow(FOLLOW_7);
+            rule__MappingDefinition__Group_8_1__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_8_1__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8_1__0"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8_1__0__Impl"
+    // InternalCftLanguage.g:2050:1: rule__MappingDefinition__Group_8_1__0__Impl : ( ( rule__MappingDefinition__Alternatives_8_1_0 ) ) ;
+    public final void rule__MappingDefinition__Group_8_1__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2054:1: ( ( ( rule__MappingDefinition__Alternatives_8_1_0 ) ) )
+            // InternalCftLanguage.g:2055:1: ( ( rule__MappingDefinition__Alternatives_8_1_0 ) )
+            {
+            // InternalCftLanguage.g:2055:1: ( ( rule__MappingDefinition__Alternatives_8_1_0 ) )
+            // InternalCftLanguage.g:2056:2: ( rule__MappingDefinition__Alternatives_8_1_0 )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getAlternatives_8_1_0()); 
+            // InternalCftLanguage.g:2057:2: ( rule__MappingDefinition__Alternatives_8_1_0 )
+            // InternalCftLanguage.g:2057:3: rule__MappingDefinition__Alternatives_8_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Alternatives_8_1_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getAlternatives_8_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8_1__0__Impl"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8_1__1"
+    // InternalCftLanguage.g:2065:1: rule__MappingDefinition__Group_8_1__1 : rule__MappingDefinition__Group_8_1__1__Impl ;
+    public final void rule__MappingDefinition__Group_8_1__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2069:1: ( rule__MappingDefinition__Group_8_1__1__Impl )
+            // InternalCftLanguage.g:2070:2: rule__MappingDefinition__Group_8_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__MappingDefinition__Group_8_1__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8_1__1"
+
+
+    // $ANTLR start "rule__MappingDefinition__Group_8_1__1__Impl"
+    // InternalCftLanguage.g:2076:1: rule__MappingDefinition__Group_8_1__1__Impl : ( ';' ) ;
+    public final void rule__MappingDefinition__Group_8_1__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2080:1: ( ( ';' ) )
+            // InternalCftLanguage.g:2081:1: ( ';' )
+            {
+            // InternalCftLanguage.g:2081:1: ( ';' )
+            // InternalCftLanguage.g:2082:2: ';'
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getSemicolonKeyword_8_1_1()); 
+            match(input,14,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getSemicolonKeyword_8_1_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__Group_8_1__1__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__0"
+    // InternalCftLanguage.g:2092:1: rule__LookupDefinition__Group__0 : rule__LookupDefinition__Group__0__Impl rule__LookupDefinition__Group__1 ;
+    public final void rule__LookupDefinition__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2096:1: ( rule__LookupDefinition__Group__0__Impl rule__LookupDefinition__Group__1 )
+            // InternalCftLanguage.g:2097:2: rule__LookupDefinition__Group__0__Impl rule__LookupDefinition__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__LookupDefinition__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__0"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__0__Impl"
+    // InternalCftLanguage.g:2104:1: rule__LookupDefinition__Group__0__Impl : ( 'lookup' ) ;
+    public final void rule__LookupDefinition__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2108:1: ( ( 'lookup' ) )
+            // InternalCftLanguage.g:2109:1: ( 'lookup' )
+            {
+            // InternalCftLanguage.g:2109:1: ( 'lookup' )
+            // InternalCftLanguage.g:2110:2: 'lookup'
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getLookupKeyword_0()); 
+            match(input,30,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getLookupKeyword_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__0__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__1"
+    // InternalCftLanguage.g:2119:1: rule__LookupDefinition__Group__1 : rule__LookupDefinition__Group__1__Impl rule__LookupDefinition__Group__2 ;
+    public final void rule__LookupDefinition__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2123:1: ( rule__LookupDefinition__Group__1__Impl rule__LookupDefinition__Group__2 )
+            // InternalCftLanguage.g:2124:2: rule__LookupDefinition__Group__1__Impl rule__LookupDefinition__Group__2
+            {
+            pushFollow(FOLLOW_22);
+            rule__LookupDefinition__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__1"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__1__Impl"
+    // InternalCftLanguage.g:2131:1: rule__LookupDefinition__Group__1__Impl : ( ( rule__LookupDefinition__MappingAssignment_1 ) ) ;
+    public final void rule__LookupDefinition__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2135:1: ( ( ( rule__LookupDefinition__MappingAssignment_1 ) ) )
+            // InternalCftLanguage.g:2136:1: ( ( rule__LookupDefinition__MappingAssignment_1 ) )
+            {
+            // InternalCftLanguage.g:2136:1: ( ( rule__LookupDefinition__MappingAssignment_1 ) )
+            // InternalCftLanguage.g:2137:2: ( rule__LookupDefinition__MappingAssignment_1 )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getMappingAssignment_1()); 
+            // InternalCftLanguage.g:2138:2: ( rule__LookupDefinition__MappingAssignment_1 )
+            // InternalCftLanguage.g:2138:3: rule__LookupDefinition__MappingAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__MappingAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getMappingAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__1__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__2"
+    // InternalCftLanguage.g:2146:1: rule__LookupDefinition__Group__2 : rule__LookupDefinition__Group__2__Impl rule__LookupDefinition__Group__3 ;
+    public final void rule__LookupDefinition__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2150:1: ( rule__LookupDefinition__Group__2__Impl rule__LookupDefinition__Group__3 )
+            // InternalCftLanguage.g:2151:2: rule__LookupDefinition__Group__2__Impl rule__LookupDefinition__Group__3
+            {
+            pushFollow(FOLLOW_3);
+            rule__LookupDefinition__Group__2__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__3();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__2"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__2__Impl"
+    // InternalCftLanguage.g:2158:1: rule__LookupDefinition__Group__2__Impl : ( '(' ) ;
+    public final void rule__LookupDefinition__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2162:1: ( ( '(' ) )
+            // InternalCftLanguage.g:2163:1: ( '(' )
+            {
+            // InternalCftLanguage.g:2163:1: ( '(' )
+            // InternalCftLanguage.g:2164:2: '('
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getLeftParenthesisKeyword_2()); 
+            match(input,27,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getLeftParenthesisKeyword_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__2__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__3"
+    // InternalCftLanguage.g:2173:1: rule__LookupDefinition__Group__3 : rule__LookupDefinition__Group__3__Impl rule__LookupDefinition__Group__4 ;
+    public final void rule__LookupDefinition__Group__3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2177:1: ( rule__LookupDefinition__Group__3__Impl rule__LookupDefinition__Group__4 )
+            // InternalCftLanguage.g:2178:2: rule__LookupDefinition__Group__3__Impl rule__LookupDefinition__Group__4
+            {
+            pushFollow(FOLLOW_23);
+            rule__LookupDefinition__Group__3__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__4();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__3"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__3__Impl"
+    // InternalCftLanguage.g:2185:1: rule__LookupDefinition__Group__3__Impl : ( ( rule__LookupDefinition__ArgumentsAssignment_3 ) ) ;
+    public final void rule__LookupDefinition__Group__3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2189:1: ( ( ( rule__LookupDefinition__ArgumentsAssignment_3 ) ) )
+            // InternalCftLanguage.g:2190:1: ( ( rule__LookupDefinition__ArgumentsAssignment_3 ) )
+            {
+            // InternalCftLanguage.g:2190:1: ( ( rule__LookupDefinition__ArgumentsAssignment_3 ) )
+            // InternalCftLanguage.g:2191:2: ( rule__LookupDefinition__ArgumentsAssignment_3 )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getArgumentsAssignment_3()); 
+            // InternalCftLanguage.g:2192:2: ( rule__LookupDefinition__ArgumentsAssignment_3 )
+            // InternalCftLanguage.g:2192:3: rule__LookupDefinition__ArgumentsAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__ArgumentsAssignment_3();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getArgumentsAssignment_3()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__3__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__4"
+    // InternalCftLanguage.g:2200:1: rule__LookupDefinition__Group__4 : rule__LookupDefinition__Group__4__Impl rule__LookupDefinition__Group__5 ;
+    public final void rule__LookupDefinition__Group__4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2204:1: ( rule__LookupDefinition__Group__4__Impl rule__LookupDefinition__Group__5 )
+            // InternalCftLanguage.g:2205:2: rule__LookupDefinition__Group__4__Impl rule__LookupDefinition__Group__5
+            {
+            pushFollow(FOLLOW_23);
+            rule__LookupDefinition__Group__4__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__5();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__4"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__4__Impl"
+    // InternalCftLanguage.g:2212:1: rule__LookupDefinition__Group__4__Impl : ( ( rule__LookupDefinition__Group_4__0 )* ) ;
+    public final void rule__LookupDefinition__Group__4__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2216:1: ( ( ( rule__LookupDefinition__Group_4__0 )* ) )
+            // InternalCftLanguage.g:2217:1: ( ( rule__LookupDefinition__Group_4__0 )* )
+            {
+            // InternalCftLanguage.g:2217:1: ( ( rule__LookupDefinition__Group_4__0 )* )
+            // InternalCftLanguage.g:2218:2: ( rule__LookupDefinition__Group_4__0 )*
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getGroup_4()); 
+            // InternalCftLanguage.g:2219:2: ( rule__LookupDefinition__Group_4__0 )*
+            loop22:
+            do {
+                int alt22=2;
+                int LA22_0 = input.LA(1);
+
+                if ( (LA22_0==29) ) {
+                    alt22=1;
+                }
+
+
+                switch (alt22) {
+                case 1 :
+                    // InternalCftLanguage.g:2219:3: rule__LookupDefinition__Group_4__0
+                    {
+                    pushFollow(FOLLOW_24);
+                    rule__LookupDefinition__Group_4__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop22;
+                }
+            } while (true);
+
+             after(grammarAccess.getLookupDefinitionAccess().getGroup_4()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__4__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__5"
+    // InternalCftLanguage.g:2227:1: rule__LookupDefinition__Group__5 : rule__LookupDefinition__Group__5__Impl rule__LookupDefinition__Group__6 ;
+    public final void rule__LookupDefinition__Group__5() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2231:1: ( rule__LookupDefinition__Group__5__Impl rule__LookupDefinition__Group__6 )
+            // InternalCftLanguage.g:2232:2: rule__LookupDefinition__Group__5__Impl rule__LookupDefinition__Group__6
+            {
+            pushFollow(FOLLOW_28);
+            rule__LookupDefinition__Group__5__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__6();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__5"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__5__Impl"
+    // InternalCftLanguage.g:2239:1: rule__LookupDefinition__Group__5__Impl : ( ')' ) ;
+    public final void rule__LookupDefinition__Group__5__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2243:1: ( ( ')' ) )
+            // InternalCftLanguage.g:2244:1: ( ')' )
+            {
+            // InternalCftLanguage.g:2244:1: ( ')' )
+            // InternalCftLanguage.g:2245:2: ')'
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getRightParenthesisKeyword_5()); 
+            match(input,28,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getRightParenthesisKeyword_5()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__5__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__6"
+    // InternalCftLanguage.g:2254:1: rule__LookupDefinition__Group__6 : rule__LookupDefinition__Group__6__Impl rule__LookupDefinition__Group__7 ;
+    public final void rule__LookupDefinition__Group__6() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2258:1: ( rule__LookupDefinition__Group__6__Impl rule__LookupDefinition__Group__7 )
+            // InternalCftLanguage.g:2259:2: rule__LookupDefinition__Group__6__Impl rule__LookupDefinition__Group__7
+            {
+            pushFollow(FOLLOW_3);
+            rule__LookupDefinition__Group__6__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__7();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__6"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__6__Impl"
+    // InternalCftLanguage.g:2266:1: rule__LookupDefinition__Group__6__Impl : ( 'as' ) ;
+    public final void rule__LookupDefinition__Group__6__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2270:1: ( ( 'as' ) )
+            // InternalCftLanguage.g:2271:1: ( 'as' )
+            {
+            // InternalCftLanguage.g:2271:1: ( 'as' )
+            // InternalCftLanguage.g:2272:2: 'as'
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getAsKeyword_6()); 
+            match(input,31,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getAsKeyword_6()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__6__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__7"
+    // InternalCftLanguage.g:2281:1: rule__LookupDefinition__Group__7 : rule__LookupDefinition__Group__7__Impl ;
+    public final void rule__LookupDefinition__Group__7() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2285:1: ( rule__LookupDefinition__Group__7__Impl )
+            // InternalCftLanguage.g:2286:2: rule__LookupDefinition__Group__7__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group__7__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__7"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group__7__Impl"
+    // InternalCftLanguage.g:2292:1: rule__LookupDefinition__Group__7__Impl : ( ( rule__LookupDefinition__NameAssignment_7 ) ) ;
+    public final void rule__LookupDefinition__Group__7__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2296:1: ( ( ( rule__LookupDefinition__NameAssignment_7 ) ) )
+            // InternalCftLanguage.g:2297:1: ( ( rule__LookupDefinition__NameAssignment_7 ) )
+            {
+            // InternalCftLanguage.g:2297:1: ( ( rule__LookupDefinition__NameAssignment_7 ) )
+            // InternalCftLanguage.g:2298:2: ( rule__LookupDefinition__NameAssignment_7 )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getNameAssignment_7()); 
+            // InternalCftLanguage.g:2299:2: ( rule__LookupDefinition__NameAssignment_7 )
+            // InternalCftLanguage.g:2299:3: rule__LookupDefinition__NameAssignment_7
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__NameAssignment_7();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getNameAssignment_7()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group__7__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group_4__0"
+    // InternalCftLanguage.g:2308:1: rule__LookupDefinition__Group_4__0 : rule__LookupDefinition__Group_4__0__Impl rule__LookupDefinition__Group_4__1 ;
+    public final void rule__LookupDefinition__Group_4__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2312:1: ( rule__LookupDefinition__Group_4__0__Impl rule__LookupDefinition__Group_4__1 )
+            // InternalCftLanguage.g:2313:2: rule__LookupDefinition__Group_4__0__Impl rule__LookupDefinition__Group_4__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__LookupDefinition__Group_4__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group_4__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group_4__0"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group_4__0__Impl"
+    // InternalCftLanguage.g:2320:1: rule__LookupDefinition__Group_4__0__Impl : ( ',' ) ;
+    public final void rule__LookupDefinition__Group_4__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2324:1: ( ( ',' ) )
+            // InternalCftLanguage.g:2325:1: ( ',' )
+            {
+            // InternalCftLanguage.g:2325:1: ( ',' )
+            // InternalCftLanguage.g:2326:2: ','
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getCommaKeyword_4_0()); 
+            match(input,29,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getCommaKeyword_4_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group_4__0__Impl"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group_4__1"
+    // InternalCftLanguage.g:2335:1: rule__LookupDefinition__Group_4__1 : rule__LookupDefinition__Group_4__1__Impl ;
+    public final void rule__LookupDefinition__Group_4__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2339:1: ( rule__LookupDefinition__Group_4__1__Impl )
+            // InternalCftLanguage.g:2340:2: rule__LookupDefinition__Group_4__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__Group_4__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group_4__1"
+
+
+    // $ANTLR start "rule__LookupDefinition__Group_4__1__Impl"
+    // InternalCftLanguage.g:2346:1: rule__LookupDefinition__Group_4__1__Impl : ( ( rule__LookupDefinition__ArgumentsAssignment_4_1 ) ) ;
+    public final void rule__LookupDefinition__Group_4__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2350:1: ( ( ( rule__LookupDefinition__ArgumentsAssignment_4_1 ) ) )
+            // InternalCftLanguage.g:2351:1: ( ( rule__LookupDefinition__ArgumentsAssignment_4_1 ) )
+            {
+            // InternalCftLanguage.g:2351:1: ( ( rule__LookupDefinition__ArgumentsAssignment_4_1 ) )
+            // InternalCftLanguage.g:2352:2: ( rule__LookupDefinition__ArgumentsAssignment_4_1 )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getArgumentsAssignment_4_1()); 
+            // InternalCftLanguage.g:2353:2: ( rule__LookupDefinition__ArgumentsAssignment_4_1 )
+            // InternalCftLanguage.g:2353:3: rule__LookupDefinition__ArgumentsAssignment_4_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__LookupDefinition__ArgumentsAssignment_4_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getArgumentsAssignment_4_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__Group_4__1__Impl"
+
+
+    // $ANTLR start "rule__Assignment__Group__0"
+    // InternalCftLanguage.g:2362:1: rule__Assignment__Group__0 : rule__Assignment__Group__0__Impl rule__Assignment__Group__1 ;
+    public final void rule__Assignment__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2366:1: ( rule__Assignment__Group__0__Impl rule__Assignment__Group__1 )
+            // InternalCftLanguage.g:2367:2: rule__Assignment__Group__0__Impl rule__Assignment__Group__1
+            {
+            pushFollow(FOLLOW_29);
+            rule__Assignment__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__Assignment__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Group__0"
+
+
+    // $ANTLR start "rule__Assignment__Group__0__Impl"
+    // InternalCftLanguage.g:2374:1: rule__Assignment__Group__0__Impl : ( ( rule__Assignment__InputAssignment_0 ) ) ;
+    public final void rule__Assignment__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2378:1: ( ( ( rule__Assignment__InputAssignment_0 ) ) )
+            // InternalCftLanguage.g:2379:1: ( ( rule__Assignment__InputAssignment_0 ) )
+            {
+            // InternalCftLanguage.g:2379:1: ( ( rule__Assignment__InputAssignment_0 ) )
+            // InternalCftLanguage.g:2380:2: ( rule__Assignment__InputAssignment_0 )
+            {
+             before(grammarAccess.getAssignmentAccess().getInputAssignment_0()); 
+            // InternalCftLanguage.g:2381:2: ( rule__Assignment__InputAssignment_0 )
+            // InternalCftLanguage.g:2381:3: rule__Assignment__InputAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__Assignment__InputAssignment_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getAssignmentAccess().getInputAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Group__0__Impl"
+
+
+    // $ANTLR start "rule__Assignment__Group__1"
+    // InternalCftLanguage.g:2389:1: rule__Assignment__Group__1 : rule__Assignment__Group__1__Impl rule__Assignment__Group__2 ;
+    public final void rule__Assignment__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2393:1: ( rule__Assignment__Group__1__Impl rule__Assignment__Group__2 )
+            // InternalCftLanguage.g:2394:2: rule__Assignment__Group__1__Impl rule__Assignment__Group__2
+            {
+            pushFollow(FOLLOW_30);
+            rule__Assignment__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__Assignment__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Group__1"
+
+
+    // $ANTLR start "rule__Assignment__Group__1__Impl"
+    // InternalCftLanguage.g:2401:1: rule__Assignment__Group__1__Impl : ( ( rule__Assignment__Alternatives_1 ) ) ;
+    public final void rule__Assignment__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2405:1: ( ( ( rule__Assignment__Alternatives_1 ) ) )
+            // InternalCftLanguage.g:2406:1: ( ( rule__Assignment__Alternatives_1 ) )
+            {
+            // InternalCftLanguage.g:2406:1: ( ( rule__Assignment__Alternatives_1 ) )
+            // InternalCftLanguage.g:2407:2: ( rule__Assignment__Alternatives_1 )
+            {
+             before(grammarAccess.getAssignmentAccess().getAlternatives_1()); 
+            // InternalCftLanguage.g:2408:2: ( rule__Assignment__Alternatives_1 )
+            // InternalCftLanguage.g:2408:3: rule__Assignment__Alternatives_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__Assignment__Alternatives_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getAssignmentAccess().getAlternatives_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Group__1__Impl"
+
+
+    // $ANTLR start "rule__Assignment__Group__2"
+    // InternalCftLanguage.g:2416:1: rule__Assignment__Group__2 : rule__Assignment__Group__2__Impl ;
+    public final void rule__Assignment__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2420:1: ( rule__Assignment__Group__2__Impl )
+            // InternalCftLanguage.g:2421:2: rule__Assignment__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__Assignment__Group__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Group__2"
+
+
+    // $ANTLR start "rule__Assignment__Group__2__Impl"
+    // InternalCftLanguage.g:2427:1: rule__Assignment__Group__2__Impl : ( ( rule__Assignment__OutputAssignment_2 ) ) ;
+    public final void rule__Assignment__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2431:1: ( ( ( rule__Assignment__OutputAssignment_2 ) ) )
+            // InternalCftLanguage.g:2432:1: ( ( rule__Assignment__OutputAssignment_2 ) )
+            {
+            // InternalCftLanguage.g:2432:1: ( ( rule__Assignment__OutputAssignment_2 ) )
+            // InternalCftLanguage.g:2433:2: ( rule__Assignment__OutputAssignment_2 )
+            {
+             before(grammarAccess.getAssignmentAccess().getOutputAssignment_2()); 
+            // InternalCftLanguage.g:2434:2: ( rule__Assignment__OutputAssignment_2 )
+            // InternalCftLanguage.g:2434:3: rule__Assignment__OutputAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__Assignment__OutputAssignment_2();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getAssignmentAccess().getOutputAssignment_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__Group__2__Impl"
+
+
+    // $ANTLR start "rule__EventReference__Group__0"
+    // InternalCftLanguage.g:2443:1: rule__EventReference__Group__0 : rule__EventReference__Group__0__Impl rule__EventReference__Group__1 ;
+    public final void rule__EventReference__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2447:1: ( rule__EventReference__Group__0__Impl rule__EventReference__Group__1 )
+            // InternalCftLanguage.g:2448:2: rule__EventReference__Group__0__Impl rule__EventReference__Group__1
+            {
+            pushFollow(FOLLOW_31);
+            rule__EventReference__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__EventReference__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__Group__0"
+
+
+    // $ANTLR start "rule__EventReference__Group__0__Impl"
+    // InternalCftLanguage.g:2455:1: rule__EventReference__Group__0__Impl : ( ( rule__EventReference__ComponentAssignment_0 ) ) ;
+    public final void rule__EventReference__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2459:1: ( ( ( rule__EventReference__ComponentAssignment_0 ) ) )
+            // InternalCftLanguage.g:2460:1: ( ( rule__EventReference__ComponentAssignment_0 ) )
+            {
+            // InternalCftLanguage.g:2460:1: ( ( rule__EventReference__ComponentAssignment_0 ) )
+            // InternalCftLanguage.g:2461:2: ( rule__EventReference__ComponentAssignment_0 )
+            {
+             before(grammarAccess.getEventReferenceAccess().getComponentAssignment_0()); 
+            // InternalCftLanguage.g:2462:2: ( rule__EventReference__ComponentAssignment_0 )
+            // InternalCftLanguage.g:2462:3: rule__EventReference__ComponentAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__EventReference__ComponentAssignment_0();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getEventReferenceAccess().getComponentAssignment_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__Group__0__Impl"
+
+
+    // $ANTLR start "rule__EventReference__Group__1"
+    // InternalCftLanguage.g:2470:1: rule__EventReference__Group__1 : rule__EventReference__Group__1__Impl rule__EventReference__Group__2 ;
+    public final void rule__EventReference__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2474:1: ( rule__EventReference__Group__1__Impl rule__EventReference__Group__2 )
+            // InternalCftLanguage.g:2475:2: rule__EventReference__Group__1__Impl rule__EventReference__Group__2
+            {
+            pushFollow(FOLLOW_3);
+            rule__EventReference__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__EventReference__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__Group__1"
+
+
+    // $ANTLR start "rule__EventReference__Group__1__Impl"
+    // InternalCftLanguage.g:2482:1: rule__EventReference__Group__1__Impl : ( '.' ) ;
+    public final void rule__EventReference__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2486:1: ( ( '.' ) )
+            // InternalCftLanguage.g:2487:1: ( '.' )
+            {
+            // InternalCftLanguage.g:2487:1: ( '.' )
+            // InternalCftLanguage.g:2488:2: '.'
+            {
+             before(grammarAccess.getEventReferenceAccess().getFullStopKeyword_1()); 
+            match(input,32,FOLLOW_2); 
+             after(grammarAccess.getEventReferenceAccess().getFullStopKeyword_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__Group__1__Impl"
+
+
+    // $ANTLR start "rule__EventReference__Group__2"
+    // InternalCftLanguage.g:2497:1: rule__EventReference__Group__2 : rule__EventReference__Group__2__Impl ;
+    public final void rule__EventReference__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2501:1: ( rule__EventReference__Group__2__Impl )
+            // InternalCftLanguage.g:2502:2: rule__EventReference__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__EventReference__Group__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__Group__2"
+
+
+    // $ANTLR start "rule__EventReference__Group__2__Impl"
+    // InternalCftLanguage.g:2508:1: rule__EventReference__Group__2__Impl : ( ( rule__EventReference__EventAssignment_2 ) ) ;
+    public final void rule__EventReference__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2512:1: ( ( ( rule__EventReference__EventAssignment_2 ) ) )
+            // InternalCftLanguage.g:2513:1: ( ( rule__EventReference__EventAssignment_2 ) )
+            {
+            // InternalCftLanguage.g:2513:1: ( ( rule__EventReference__EventAssignment_2 ) )
+            // InternalCftLanguage.g:2514:2: ( rule__EventReference__EventAssignment_2 )
+            {
+             before(grammarAccess.getEventReferenceAccess().getEventAssignment_2()); 
+            // InternalCftLanguage.g:2515:2: ( rule__EventReference__EventAssignment_2 )
+            // InternalCftLanguage.g:2515:3: rule__EventReference__EventAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__EventReference__EventAssignment_2();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getEventReferenceAccess().getEventAssignment_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__Group__2__Impl"
+
+
+    // $ANTLR start "rule__ComponentInstance__Group__0"
+    // InternalCftLanguage.g:2524:1: rule__ComponentInstance__Group__0 : rule__ComponentInstance__Group__0__Impl rule__ComponentInstance__Group__1 ;
+    public final void rule__ComponentInstance__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2528:1: ( rule__ComponentInstance__Group__0__Impl rule__ComponentInstance__Group__1 )
+            // InternalCftLanguage.g:2529:2: rule__ComponentInstance__Group__0__Impl rule__ComponentInstance__Group__1
+            {
+            pushFollow(FOLLOW_3);
+            rule__ComponentInstance__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentInstance__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__Group__0"
+
+
+    // $ANTLR start "rule__ComponentInstance__Group__0__Impl"
+    // InternalCftLanguage.g:2536:1: rule__ComponentInstance__Group__0__Impl : ( '=>' ) ;
+    public final void rule__ComponentInstance__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2540:1: ( ( '=>' ) )
+            // InternalCftLanguage.g:2541:1: ( '=>' )
+            {
+            // InternalCftLanguage.g:2541:1: ( '=>' )
+            // InternalCftLanguage.g:2542:2: '=>'
+            {
+             before(grammarAccess.getComponentInstanceAccess().getEqualsSignGreaterThanSignKeyword_0()); 
+            match(input,33,FOLLOW_2); 
+             after(grammarAccess.getComponentInstanceAccess().getEqualsSignGreaterThanSignKeyword_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__Group__0__Impl"
+
+
+    // $ANTLR start "rule__ComponentInstance__Group__1"
+    // InternalCftLanguage.g:2551:1: rule__ComponentInstance__Group__1 : rule__ComponentInstance__Group__1__Impl rule__ComponentInstance__Group__2 ;
+    public final void rule__ComponentInstance__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2555:1: ( rule__ComponentInstance__Group__1__Impl rule__ComponentInstance__Group__2 )
+            // InternalCftLanguage.g:2556:2: rule__ComponentInstance__Group__1__Impl rule__ComponentInstance__Group__2
+            {
+            pushFollow(FOLLOW_3);
+            rule__ComponentInstance__Group__1__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__ComponentInstance__Group__2();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__Group__1"
+
+
+    // $ANTLR start "rule__ComponentInstance__Group__1__Impl"
+    // InternalCftLanguage.g:2563:1: rule__ComponentInstance__Group__1__Impl : ( ( rule__ComponentInstance__ComponentTypeAssignment_1 ) ) ;
+    public final void rule__ComponentInstance__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2567:1: ( ( ( rule__ComponentInstance__ComponentTypeAssignment_1 ) ) )
+            // InternalCftLanguage.g:2568:1: ( ( rule__ComponentInstance__ComponentTypeAssignment_1 ) )
+            {
+            // InternalCftLanguage.g:2568:1: ( ( rule__ComponentInstance__ComponentTypeAssignment_1 ) )
+            // InternalCftLanguage.g:2569:2: ( rule__ComponentInstance__ComponentTypeAssignment_1 )
+            {
+             before(grammarAccess.getComponentInstanceAccess().getComponentTypeAssignment_1()); 
+            // InternalCftLanguage.g:2570:2: ( rule__ComponentInstance__ComponentTypeAssignment_1 )
+            // InternalCftLanguage.g:2570:3: rule__ComponentInstance__ComponentTypeAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentInstance__ComponentTypeAssignment_1();
+
+            state._fsp--;
+
+
+            }
+
+             after(grammarAccess.getComponentInstanceAccess().getComponentTypeAssignment_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__Group__1__Impl"
+
+
+    // $ANTLR start "rule__ComponentInstance__Group__2"
+    // InternalCftLanguage.g:2578:1: rule__ComponentInstance__Group__2 : rule__ComponentInstance__Group__2__Impl ;
+    public final void rule__ComponentInstance__Group__2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2582:1: ( rule__ComponentInstance__Group__2__Impl )
+            // InternalCftLanguage.g:2583:2: rule__ComponentInstance__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentInstance__Group__2__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__Group__2"
+
+
+    // $ANTLR start "rule__ComponentInstance__Group__2__Impl"
+    // InternalCftLanguage.g:2589:1: rule__ComponentInstance__Group__2__Impl : ( ( rule__ComponentInstance__NameAssignment_2 )? ) ;
+    public final void rule__ComponentInstance__Group__2__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2593:1: ( ( ( rule__ComponentInstance__NameAssignment_2 )? ) )
+            // InternalCftLanguage.g:2594:1: ( ( rule__ComponentInstance__NameAssignment_2 )? )
+            {
+            // InternalCftLanguage.g:2594:1: ( ( rule__ComponentInstance__NameAssignment_2 )? )
+            // InternalCftLanguage.g:2595:2: ( rule__ComponentInstance__NameAssignment_2 )?
+            {
+             before(grammarAccess.getComponentInstanceAccess().getNameAssignment_2()); 
+            // InternalCftLanguage.g:2596:2: ( rule__ComponentInstance__NameAssignment_2 )?
+            int alt23=2;
+            int LA23_0 = input.LA(1);
+
+            if ( (LA23_0==RULE_ID) ) {
+                alt23=1;
+            }
+            switch (alt23) {
+                case 1 :
+                    // InternalCftLanguage.g:2596:3: rule__ComponentInstance__NameAssignment_2
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__ComponentInstance__NameAssignment_2();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getComponentInstanceAccess().getNameAssignment_2()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__Group__2__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group__0"
+    // InternalCftLanguage.g:2605: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 {
+            // InternalCftLanguage.g:2609:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 )
+            // InternalCftLanguage.g:2610:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1
+            {
+            pushFollow(FOLLOW_31);
+            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"
+    // InternalCftLanguage.g:2617:1: rule__QualifiedName__Group__0__Impl : ( RULE_ID ) ;
+    public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2621:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:2622:1: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:2622:1: ( RULE_ID )
+            // InternalCftLanguage.g:2623:2: RULE_ID
+            {
+             before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group__1"
+    // InternalCftLanguage.g:2632:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ;
+    public final void rule__QualifiedName__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2636:1: ( rule__QualifiedName__Group__1__Impl )
+            // InternalCftLanguage.g:2637: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"
+    // InternalCftLanguage.g:2643: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 {
+            // InternalCftLanguage.g:2647:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) )
+            // InternalCftLanguage.g:2648:1: ( ( rule__QualifiedName__Group_1__0 )* )
+            {
+            // InternalCftLanguage.g:2648:1: ( ( rule__QualifiedName__Group_1__0 )* )
+            // InternalCftLanguage.g:2649:2: ( rule__QualifiedName__Group_1__0 )*
+            {
+             before(grammarAccess.getQualifiedNameAccess().getGroup_1()); 
+            // InternalCftLanguage.g:2650:2: ( rule__QualifiedName__Group_1__0 )*
+            loop24:
+            do {
+                int alt24=2;
+                int LA24_0 = input.LA(1);
+
+                if ( (LA24_0==32) ) {
+                    int LA24_2 = input.LA(2);
+
+                    if ( (LA24_2==RULE_ID) ) {
+                        alt24=1;
+                    }
+
+
+                }
+
+
+                switch (alt24) {
+                case 1 :
+                    // InternalCftLanguage.g:2650:3: rule__QualifiedName__Group_1__0
+                    {
+                    pushFollow(FOLLOW_32);
+                    rule__QualifiedName__Group_1__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+                default :
+                    break loop24;
+                }
+            } 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"
+    // InternalCftLanguage.g:2659: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 {
+            // InternalCftLanguage.g:2663:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 )
+            // InternalCftLanguage.g:2664:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1
+            {
+            pushFollow(FOLLOW_3);
+            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"
+    // InternalCftLanguage.g:2671:1: rule__QualifiedName__Group_1__0__Impl : ( '.' ) ;
+    public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2675:1: ( ( '.' ) )
+            // InternalCftLanguage.g:2676:1: ( '.' )
+            {
+            // InternalCftLanguage.g:2676:1: ( '.' )
+            // InternalCftLanguage.g:2677:2: '.'
+            {
+             before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
+            match(input,32,FOLLOW_2); 
+             after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group_1__1"
+    // InternalCftLanguage.g:2686: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 {
+            // InternalCftLanguage.g:2690:1: ( rule__QualifiedName__Group_1__1__Impl )
+            // InternalCftLanguage.g:2691: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"
+    // InternalCftLanguage.g:2697:1: rule__QualifiedName__Group_1__1__Impl : ( RULE_ID ) ;
+    public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2701:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:2702:1: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:2702:1: ( RULE_ID )
+            // InternalCftLanguage.g:2703:2: RULE_ID
+            {
+             before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0"
+    // InternalCftLanguage.g:2713:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ;
+    public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2717:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 )
+            // InternalCftLanguage.g:2718:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1
+            {
+            pushFollow(FOLLOW_31);
+            rule__QualifiedNameWithWildcard__Group__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl"
+    // InternalCftLanguage.g:2725:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ;
+    public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2729:1: ( ( ruleQualifiedName ) )
+            // InternalCftLanguage.g:2730:1: ( ruleQualifiedName )
+            {
+            // InternalCftLanguage.g:2730:1: ( ruleQualifiedName )
+            // InternalCftLanguage.g:2731:2: ruleQualifiedName
+            {
+             before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); 
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+
+             after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1"
+    // InternalCftLanguage.g:2740:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl ;
+    public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2744:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl )
+            // InternalCftLanguage.g:2745:2: rule__QualifiedNameWithWildcard__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl"
+    // InternalCftLanguage.g:2751:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( ( rule__QualifiedNameWithWildcard__Group_1__0 )? ) ;
+    public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2755:1: ( ( ( rule__QualifiedNameWithWildcard__Group_1__0 )? ) )
+            // InternalCftLanguage.g:2756:1: ( ( rule__QualifiedNameWithWildcard__Group_1__0 )? )
+            {
+            // InternalCftLanguage.g:2756:1: ( ( rule__QualifiedNameWithWildcard__Group_1__0 )? )
+            // InternalCftLanguage.g:2757:2: ( rule__QualifiedNameWithWildcard__Group_1__0 )?
+            {
+             before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup_1()); 
+            // InternalCftLanguage.g:2758:2: ( rule__QualifiedNameWithWildcard__Group_1__0 )?
+            int alt25=2;
+            int LA25_0 = input.LA(1);
+
+            if ( (LA25_0==32) ) {
+                alt25=1;
+            }
+            switch (alt25) {
+                case 1 :
+                    // InternalCftLanguage.g:2758:3: rule__QualifiedNameWithWildcard__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__QualifiedNameWithWildcard__Group_1__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+             after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group_1__0"
+    // InternalCftLanguage.g:2767:1: rule__QualifiedNameWithWildcard__Group_1__0 : rule__QualifiedNameWithWildcard__Group_1__0__Impl rule__QualifiedNameWithWildcard__Group_1__1 ;
+    public final void rule__QualifiedNameWithWildcard__Group_1__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2771:1: ( rule__QualifiedNameWithWildcard__Group_1__0__Impl rule__QualifiedNameWithWildcard__Group_1__1 )
+            // InternalCftLanguage.g:2772:2: rule__QualifiedNameWithWildcard__Group_1__0__Impl rule__QualifiedNameWithWildcard__Group_1__1
+            {
+            pushFollow(FOLLOW_33);
+            rule__QualifiedNameWithWildcard__Group_1__0__Impl();
+
+            state._fsp--;
+
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group_1__1();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group_1__0"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group_1__0__Impl"
+    // InternalCftLanguage.g:2779:1: rule__QualifiedNameWithWildcard__Group_1__0__Impl : ( '.' ) ;
+    public final void rule__QualifiedNameWithWildcard__Group_1__0__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2783:1: ( ( '.' ) )
+            // InternalCftLanguage.g:2784:1: ( '.' )
+            {
+            // InternalCftLanguage.g:2784:1: ( '.' )
+            // InternalCftLanguage.g:2785:2: '.'
+            {
+             before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1_0()); 
+            match(input,32,FOLLOW_2); 
+             after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group_1__1"
+    // InternalCftLanguage.g:2794:1: rule__QualifiedNameWithWildcard__Group_1__1 : rule__QualifiedNameWithWildcard__Group_1__1__Impl ;
+    public final void rule__QualifiedNameWithWildcard__Group_1__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2798:1: ( rule__QualifiedNameWithWildcard__Group_1__1__Impl )
+            // InternalCftLanguage.g:2799:2: rule__QualifiedNameWithWildcard__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group_1__1__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group_1__1"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group_1__1__Impl"
+    // InternalCftLanguage.g:2805:1: rule__QualifiedNameWithWildcard__Group_1__1__Impl : ( '*' ) ;
+    public final void rule__QualifiedNameWithWildcard__Group_1__1__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2809:1: ( ( '*' ) )
+            // InternalCftLanguage.g:2810:1: ( '*' )
+            {
+            // InternalCftLanguage.g:2810:1: ( '*' )
+            // InternalCftLanguage.g:2811:2: '*'
+            {
+             before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_1_1()); 
+            match(input,34,FOLLOW_2); 
+             after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_1_1()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__UnorderedGroup_3"
+    // InternalCftLanguage.g:2821:1: rule__ComponentDefinition__UnorderedGroup_3 : ( rule__ComponentDefinition__UnorderedGroup_3__0 )? ;
+    public final void rule__ComponentDefinition__UnorderedGroup_3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                        getUnorderedGroupHelper().enter(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3());
+                
+        try {
+            // InternalCftLanguage.g:2826:1: ( ( rule__ComponentDefinition__UnorderedGroup_3__0 )? )
+            // InternalCftLanguage.g:2827:2: ( rule__ComponentDefinition__UnorderedGroup_3__0 )?
+            {
+            // InternalCftLanguage.g:2827:2: ( rule__ComponentDefinition__UnorderedGroup_3__0 )?
+            int alt26=2;
+            int LA26_0 = input.LA(1);
+
+            if ( LA26_0 == 19 && getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 0) ) {
+                alt26=1;
+            }
+            else if ( LA26_0 == 20 && getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 1) ) {
+                alt26=1;
+            }
+            switch (alt26) {
+                case 1 :
+                    // InternalCftLanguage.g:2827:2: rule__ComponentDefinition__UnorderedGroup_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__ComponentDefinition__UnorderedGroup_3__0();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                getUnorderedGroupHelper().leave(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3());
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__UnorderedGroup_3"
+
+
+    // $ANTLR start "rule__ComponentDefinition__UnorderedGroup_3__Impl"
+    // InternalCftLanguage.g:2835:1: rule__ComponentDefinition__UnorderedGroup_3__Impl : ( ({...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) ) ) | ({...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) ) ) ) ;
+    public final void rule__ComponentDefinition__UnorderedGroup_3__Impl() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                        boolean selected = false;
+                
+        try {
+            // InternalCftLanguage.g:2840:1: ( ( ({...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) ) ) | ({...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) ) ) ) )
+            // InternalCftLanguage.g:2841:3: ( ({...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) ) ) | ({...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) ) ) )
+            {
+            // InternalCftLanguage.g:2841:3: ( ({...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) ) ) | ({...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) ) ) )
+            int alt27=2;
+            int LA27_0 = input.LA(1);
+
+            if ( LA27_0 == 19 && getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 0) ) {
+                alt27=1;
+            }
+            else if ( LA27_0 == 20 && getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 1) ) {
+                alt27=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 27, 0, input);
+
+                throw nvae;
+            }
+            switch (alt27) {
+                case 1 :
+                    // InternalCftLanguage.g:2842:3: ({...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) ) )
+                    {
+                    // InternalCftLanguage.g:2842:3: ({...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) ) )
+                    // InternalCftLanguage.g:2843:4: {...}? => ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) )
+                    {
+                    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 0) ) {
+                        throw new FailedPredicateException(input, "rule__ComponentDefinition__UnorderedGroup_3__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 0)");
+                    }
+                    // InternalCftLanguage.g:2843:115: ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) )
+                    // InternalCftLanguage.g:2844:5: ( ( rule__ComponentDefinition__Group_3_0__0 ) )
+                    {
+
+                                                        getUnorderedGroupHelper().select(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 0);
+                                                
+
+                                                        selected = true;
+                                                
+                    // InternalCftLanguage.g:2850:5: ( ( rule__ComponentDefinition__Group_3_0__0 ) )
+                    // InternalCftLanguage.g:2851:6: ( rule__ComponentDefinition__Group_3_0__0 )
+                    {
+                     before(grammarAccess.getComponentDefinitionAccess().getGroup_3_0()); 
+                    // InternalCftLanguage.g:2852:6: ( rule__ComponentDefinition__Group_3_0__0 )
+                    // InternalCftLanguage.g:2852:7: rule__ComponentDefinition__Group_3_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__ComponentDefinition__Group_3_0__0();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getComponentDefinitionAccess().getGroup_3_0()); 
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalCftLanguage.g:2857:3: ({...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) ) )
+                    {
+                    // InternalCftLanguage.g:2857:3: ({...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) ) )
+                    // InternalCftLanguage.g:2858:4: {...}? => ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) )
+                    {
+                    if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 1) ) {
+                        throw new FailedPredicateException(input, "rule__ComponentDefinition__UnorderedGroup_3__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 1)");
+                    }
+                    // InternalCftLanguage.g:2858:115: ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) )
+                    // InternalCftLanguage.g:2859:5: ( ( rule__ComponentDefinition__Group_3_1__0 ) )
+                    {
+
+                                                        getUnorderedGroupHelper().select(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 1);
+                                                
+
+                                                        selected = true;
+                                                
+                    // InternalCftLanguage.g:2865:5: ( ( rule__ComponentDefinition__Group_3_1__0 ) )
+                    // InternalCftLanguage.g:2866:6: ( rule__ComponentDefinition__Group_3_1__0 )
+                    {
+                     before(grammarAccess.getComponentDefinitionAccess().getGroup_3_1()); 
+                    // InternalCftLanguage.g:2867:6: ( rule__ComponentDefinition__Group_3_1__0 )
+                    // InternalCftLanguage.g:2867:7: rule__ComponentDefinition__Group_3_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__ComponentDefinition__Group_3_1__0();
+
+                    state._fsp--;
+
+
+                    }
+
+                     after(grammarAccess.getComponentDefinitionAccess().getGroup_3_1()); 
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                if (selected)
+                        getUnorderedGroupHelper().returnFromSelection(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3());
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__UnorderedGroup_3__Impl"
+
+
+    // $ANTLR start "rule__ComponentDefinition__UnorderedGroup_3__0"
+    // InternalCftLanguage.g:2880:1: rule__ComponentDefinition__UnorderedGroup_3__0 : rule__ComponentDefinition__UnorderedGroup_3__Impl ( rule__ComponentDefinition__UnorderedGroup_3__1 )? ;
+    public final void rule__ComponentDefinition__UnorderedGroup_3__0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2884:1: ( rule__ComponentDefinition__UnorderedGroup_3__Impl ( rule__ComponentDefinition__UnorderedGroup_3__1 )? )
+            // InternalCftLanguage.g:2885:2: rule__ComponentDefinition__UnorderedGroup_3__Impl ( rule__ComponentDefinition__UnorderedGroup_3__1 )?
+            {
+            pushFollow(FOLLOW_34);
+            rule__ComponentDefinition__UnorderedGroup_3__Impl();
+
+            state._fsp--;
+
+            // InternalCftLanguage.g:2886:2: ( rule__ComponentDefinition__UnorderedGroup_3__1 )?
+            int alt28=2;
+            int LA28_0 = input.LA(1);
+
+            if ( LA28_0 == 19 && getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 0) ) {
+                alt28=1;
+            }
+            else if ( LA28_0 == 20 && getUnorderedGroupHelper().canSelect(grammarAccess.getComponentDefinitionAccess().getUnorderedGroup_3(), 1) ) {
+                alt28=1;
+            }
+            switch (alt28) {
+                case 1 :
+                    // InternalCftLanguage.g:2886:2: rule__ComponentDefinition__UnorderedGroup_3__1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__ComponentDefinition__UnorderedGroup_3__1();
+
+                    state._fsp--;
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__UnorderedGroup_3__0"
+
+
+    // $ANTLR start "rule__ComponentDefinition__UnorderedGroup_3__1"
+    // InternalCftLanguage.g:2892:1: rule__ComponentDefinition__UnorderedGroup_3__1 : rule__ComponentDefinition__UnorderedGroup_3__Impl ;
+    public final void rule__ComponentDefinition__UnorderedGroup_3__1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2896:1: ( rule__ComponentDefinition__UnorderedGroup_3__Impl )
+            // InternalCftLanguage.g:2897:2: rule__ComponentDefinition__UnorderedGroup_3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ComponentDefinition__UnorderedGroup_3__Impl();
+
+            state._fsp--;
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__UnorderedGroup_3__1"
+
+
+    // $ANTLR start "rule__CftModel__PackageNameAssignment_1"
+    // InternalCftLanguage.g:2904:1: rule__CftModel__PackageNameAssignment_1 : ( ruleQualifiedName ) ;
+    public final void rule__CftModel__PackageNameAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2908:1: ( ( ruleQualifiedName ) )
+            // InternalCftLanguage.g:2909:2: ( ruleQualifiedName )
+            {
+            // InternalCftLanguage.g:2909:2: ( ruleQualifiedName )
+            // InternalCftLanguage.g:2910:3: ruleQualifiedName
+            {
+             before(grammarAccess.getCftModelAccess().getPackageNameQualifiedNameParserRuleCall_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+
+             after(grammarAccess.getCftModelAccess().getPackageNameQualifiedNameParserRuleCall_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__PackageNameAssignment_1"
+
+
+    // $ANTLR start "rule__CftModel__ImportsAssignment_3"
+    // InternalCftLanguage.g:2919:1: rule__CftModel__ImportsAssignment_3 : ( ruleImportDeclaration ) ;
+    public final void rule__CftModel__ImportsAssignment_3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2923:1: ( ( ruleImportDeclaration ) )
+            // InternalCftLanguage.g:2924:2: ( ruleImportDeclaration )
+            {
+            // InternalCftLanguage.g:2924:2: ( ruleImportDeclaration )
+            // InternalCftLanguage.g:2925:3: ruleImportDeclaration
+            {
+             before(grammarAccess.getCftModelAccess().getImportsImportDeclarationParserRuleCall_3_0()); 
+            pushFollow(FOLLOW_2);
+            ruleImportDeclaration();
+
+            state._fsp--;
+
+             after(grammarAccess.getCftModelAccess().getImportsImportDeclarationParserRuleCall_3_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__ImportsAssignment_3"
+
+
+    // $ANTLR start "rule__CftModel__ComponentDefinitionsAssignment_4_0"
+    // InternalCftLanguage.g:2934:1: rule__CftModel__ComponentDefinitionsAssignment_4_0 : ( ruleComponentDefinition ) ;
+    public final void rule__CftModel__ComponentDefinitionsAssignment_4_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2938:1: ( ( ruleComponentDefinition ) )
+            // InternalCftLanguage.g:2939:2: ( ruleComponentDefinition )
+            {
+            // InternalCftLanguage.g:2939:2: ( ruleComponentDefinition )
+            // InternalCftLanguage.g:2940:3: ruleComponentDefinition
+            {
+             before(grammarAccess.getCftModelAccess().getComponentDefinitionsComponentDefinitionParserRuleCall_4_0_0()); 
+            pushFollow(FOLLOW_2);
+            ruleComponentDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getCftModelAccess().getComponentDefinitionsComponentDefinitionParserRuleCall_4_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__ComponentDefinitionsAssignment_4_0"
+
+
+    // $ANTLR start "rule__CftModel__TransformationDefinitionsAssignment_4_1"
+    // InternalCftLanguage.g:2949:1: rule__CftModel__TransformationDefinitionsAssignment_4_1 : ( ruleTransformationDefinition ) ;
+    public final void rule__CftModel__TransformationDefinitionsAssignment_4_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2953:1: ( ( ruleTransformationDefinition ) )
+            // InternalCftLanguage.g:2954:2: ( ruleTransformationDefinition )
+            {
+            // InternalCftLanguage.g:2954:2: ( ruleTransformationDefinition )
+            // InternalCftLanguage.g:2955:3: ruleTransformationDefinition
+            {
+             before(grammarAccess.getCftModelAccess().getTransformationDefinitionsTransformationDefinitionParserRuleCall_4_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleTransformationDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getCftModelAccess().getTransformationDefinitionsTransformationDefinitionParserRuleCall_4_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__CftModel__TransformationDefinitionsAssignment_4_1"
+
+
+    // $ANTLR start "rule__ImportDeclaration__ImportedNamespaceAssignment_1"
+    // InternalCftLanguage.g:2964:1: rule__ImportDeclaration__ImportedNamespaceAssignment_1 : ( ruleQualifiedNameWithWildcard ) ;
+    public final void rule__ImportDeclaration__ImportedNamespaceAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2968:1: ( ( ruleQualifiedNameWithWildcard ) )
+            // InternalCftLanguage.g:2969:2: ( ruleQualifiedNameWithWildcard )
+            {
+            // InternalCftLanguage.g:2969:2: ( ruleQualifiedNameWithWildcard )
+            // InternalCftLanguage.g:2970:3: ruleQualifiedNameWithWildcard
+            {
+             before(grammarAccess.getImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleQualifiedNameWithWildcard();
+
+            state._fsp--;
+
+             after(grammarAccess.getImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ImportDeclaration__ImportedNamespaceAssignment_1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__NameAssignment_1"
+    // InternalCftLanguage.g:2979:1: rule__ComponentDefinition__NameAssignment_1 : ( RULE_ID ) ;
+    public final void rule__ComponentDefinition__NameAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2983:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:2984:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:2984:2: ( RULE_ID )
+            // InternalCftLanguage.g:2985:3: RULE_ID
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getNameIDTerminalRuleCall_1_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getNameIDTerminalRuleCall_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__NameAssignment_1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__InputEventsAssignment_3_0_1"
+    // InternalCftLanguage.g:2994:1: rule__ComponentDefinition__InputEventsAssignment_3_0_1 : ( ruleInputEvent ) ;
+    public final void rule__ComponentDefinition__InputEventsAssignment_3_0_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:2998:1: ( ( ruleInputEvent ) )
+            // InternalCftLanguage.g:2999:2: ( ruleInputEvent )
+            {
+            // InternalCftLanguage.g:2999:2: ( ruleInputEvent )
+            // InternalCftLanguage.g:3000:3: ruleInputEvent
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getInputEventsInputEventParserRuleCall_3_0_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleInputEvent();
+
+            state._fsp--;
+
+             after(grammarAccess.getComponentDefinitionAccess().getInputEventsInputEventParserRuleCall_3_0_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__InputEventsAssignment_3_0_1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__OutputEventsAssignment_3_1_1"
+    // InternalCftLanguage.g:3009:1: rule__ComponentDefinition__OutputEventsAssignment_3_1_1 : ( ( RULE_ID ) ) ;
+    public final void rule__ComponentDefinition__OutputEventsAssignment_3_1_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3013:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3014:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3014:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3015:3: ( RULE_ID )
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getOutputEventsEventDeclarationCrossReference_3_1_1_0()); 
+            // InternalCftLanguage.g:3016:3: ( RULE_ID )
+            // InternalCftLanguage.g:3017:4: RULE_ID
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getOutputEventsEventDeclarationIDTerminalRuleCall_3_1_1_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getComponentDefinitionAccess().getOutputEventsEventDeclarationIDTerminalRuleCall_3_1_1_0_1()); 
+
+            }
+
+             after(grammarAccess.getComponentDefinitionAccess().getOutputEventsEventDeclarationCrossReference_3_1_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__OutputEventsAssignment_3_1_1"
+
+
+    // $ANTLR start "rule__ComponentDefinition__EventDefinitionsAssignment_4_0"
+    // InternalCftLanguage.g:3028:1: rule__ComponentDefinition__EventDefinitionsAssignment_4_0 : ( ruleEventDefinition ) ;
+    public final void rule__ComponentDefinition__EventDefinitionsAssignment_4_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3032:1: ( ( ruleEventDefinition ) )
+            // InternalCftLanguage.g:3033:2: ( ruleEventDefinition )
+            {
+            // InternalCftLanguage.g:3033:2: ( ruleEventDefinition )
+            // InternalCftLanguage.g:3034:3: ruleEventDefinition
+            {
+             before(grammarAccess.getComponentDefinitionAccess().getEventDefinitionsEventDefinitionParserRuleCall_4_0_0()); 
+            pushFollow(FOLLOW_2);
+            ruleEventDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getComponentDefinitionAccess().getEventDefinitionsEventDefinitionParserRuleCall_4_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentDefinition__EventDefinitionsAssignment_4_0"
+
+
+    // $ANTLR start "rule__InputEvent__NameAssignment_0"
+    // InternalCftLanguage.g:3043:1: rule__InputEvent__NameAssignment_0 : ( RULE_ID ) ;
+    public final void rule__InputEvent__NameAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3047:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3048:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3048:2: ( RULE_ID )
+            // InternalCftLanguage.g:3049:3: RULE_ID
+            {
+             before(grammarAccess.getInputEventAccess().getNameIDTerminalRuleCall_0_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getInputEventAccess().getNameIDTerminalRuleCall_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__InputEvent__NameAssignment_0"
+
+
+    // $ANTLR start "rule__InputEvent__MultipleAssignment_1"
+    // InternalCftLanguage.g:3058:1: rule__InputEvent__MultipleAssignment_1 : ( ( '[]' ) ) ;
+    public final void rule__InputEvent__MultipleAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3062:1: ( ( ( '[]' ) ) )
+            // InternalCftLanguage.g:3063:2: ( ( '[]' ) )
+            {
+            // InternalCftLanguage.g:3063:2: ( ( '[]' ) )
+            // InternalCftLanguage.g:3064:3: ( '[]' )
+            {
+             before(grammarAccess.getInputEventAccess().getMultipleLeftSquareBracketRightSquareBracketKeyword_1_0()); 
+            // InternalCftLanguage.g:3065:3: ( '[]' )
+            // InternalCftLanguage.g:3066:4: '[]'
+            {
+             before(grammarAccess.getInputEventAccess().getMultipleLeftSquareBracketRightSquareBracketKeyword_1_0()); 
+            match(input,35,FOLLOW_2); 
+             after(grammarAccess.getInputEventAccess().getMultipleLeftSquareBracketRightSquareBracketKeyword_1_0()); 
+
+            }
+
+             after(grammarAccess.getInputEventAccess().getMultipleLeftSquareBracketRightSquareBracketKeyword_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__InputEvent__MultipleAssignment_1"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__NameAssignment_0"
+    // InternalCftLanguage.g:3077:1: rule__BasicEventDefinition__NameAssignment_0 : ( RULE_ID ) ;
+    public final void rule__BasicEventDefinition__NameAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3081:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3082:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3082:2: ( RULE_ID )
+            // InternalCftLanguage.g:3083:3: RULE_ID
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getNameIDTerminalRuleCall_0_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getBasicEventDefinitionAccess().getNameIDTerminalRuleCall_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__NameAssignment_0"
+
+
+    // $ANTLR start "rule__BasicEventDefinition__RateAssignment_3"
+    // InternalCftLanguage.g:3092:1: rule__BasicEventDefinition__RateAssignment_3 : ( RULE_DOULBE ) ;
+    public final void rule__BasicEventDefinition__RateAssignment_3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3096:1: ( ( RULE_DOULBE ) )
+            // InternalCftLanguage.g:3097:2: ( RULE_DOULBE )
+            {
+            // InternalCftLanguage.g:3097:2: ( RULE_DOULBE )
+            // InternalCftLanguage.g:3098:3: RULE_DOULBE
+            {
+             before(grammarAccess.getBasicEventDefinitionAccess().getRateDOULBETerminalRuleCall_3_0()); 
+            match(input,RULE_DOULBE,FOLLOW_2); 
+             after(grammarAccess.getBasicEventDefinitionAccess().getRateDOULBETerminalRuleCall_3_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__BasicEventDefinition__RateAssignment_3"
+
+
+    // $ANTLR start "rule__AndGate__NameAssignment_0"
+    // InternalCftLanguage.g:3107:1: rule__AndGate__NameAssignment_0 : ( RULE_ID ) ;
+    public final void rule__AndGate__NameAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3111:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3112:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3112:2: ( RULE_ID )
+            // InternalCftLanguage.g:3113:3: RULE_ID
+            {
+             before(grammarAccess.getAndGateAccess().getNameIDTerminalRuleCall_0_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getAndGateAccess().getNameIDTerminalRuleCall_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__NameAssignment_0"
+
+
+    // $ANTLR start "rule__AndGate__InputEventsAssignment_2"
+    // InternalCftLanguage.g:3122:1: rule__AndGate__InputEventsAssignment_2 : ( ( RULE_ID ) ) ;
+    public final void rule__AndGate__InputEventsAssignment_2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3126:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3127:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3127:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3128:3: ( RULE_ID )
+            {
+             before(grammarAccess.getAndGateAccess().getInputEventsEventDeclarationCrossReference_2_0()); 
+            // InternalCftLanguage.g:3129:3: ( RULE_ID )
+            // InternalCftLanguage.g:3130:4: RULE_ID
+            {
+             before(grammarAccess.getAndGateAccess().getInputEventsEventDeclarationIDTerminalRuleCall_2_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getAndGateAccess().getInputEventsEventDeclarationIDTerminalRuleCall_2_0_1()); 
+
+            }
+
+             after(grammarAccess.getAndGateAccess().getInputEventsEventDeclarationCrossReference_2_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__AndGate__InputEventsAssignment_2"
+
+
+    // $ANTLR start "rule__OrGate__NameAssignment_0"
+    // InternalCftLanguage.g:3141:1: rule__OrGate__NameAssignment_0 : ( RULE_ID ) ;
+    public final void rule__OrGate__NameAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3145:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3146:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3146:2: ( RULE_ID )
+            // InternalCftLanguage.g:3147:3: RULE_ID
+            {
+             before(grammarAccess.getOrGateAccess().getNameIDTerminalRuleCall_0_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getOrGateAccess().getNameIDTerminalRuleCall_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__NameAssignment_0"
+
+
+    // $ANTLR start "rule__OrGate__InputEventsAssignment_2"
+    // InternalCftLanguage.g:3156:1: rule__OrGate__InputEventsAssignment_2 : ( ( RULE_ID ) ) ;
+    public final void rule__OrGate__InputEventsAssignment_2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3160:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3161:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3161:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3162:3: ( RULE_ID )
+            {
+             before(grammarAccess.getOrGateAccess().getInputEventsEventDeclarationCrossReference_2_0()); 
+            // InternalCftLanguage.g:3163:3: ( RULE_ID )
+            // InternalCftLanguage.g:3164:4: RULE_ID
+            {
+             before(grammarAccess.getOrGateAccess().getInputEventsEventDeclarationIDTerminalRuleCall_2_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getOrGateAccess().getInputEventsEventDeclarationIDTerminalRuleCall_2_0_1()); 
+
+            }
+
+             after(grammarAccess.getOrGateAccess().getInputEventsEventDeclarationCrossReference_2_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OrGate__InputEventsAssignment_2"
+
+
+    // $ANTLR start "rule__TransformationDefinition__NameAssignment_1"
+    // InternalCftLanguage.g:3175:1: rule__TransformationDefinition__NameAssignment_1 : ( RULE_ID ) ;
+    public final void rule__TransformationDefinition__NameAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3179:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3180:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3180:2: ( RULE_ID )
+            // InternalCftLanguage.g:3181:3: RULE_ID
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getNameIDTerminalRuleCall_1_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getTransformationDefinitionAccess().getNameIDTerminalRuleCall_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__NameAssignment_1"
+
+
+    // $ANTLR start "rule__TransformationDefinition__MappingDefinitionsAssignment_3"
+    // InternalCftLanguage.g:3190:1: rule__TransformationDefinition__MappingDefinitionsAssignment_3 : ( ruleMappingDefinition ) ;
+    public final void rule__TransformationDefinition__MappingDefinitionsAssignment_3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3194:1: ( ( ruleMappingDefinition ) )
+            // InternalCftLanguage.g:3195:2: ( ruleMappingDefinition )
+            {
+            // InternalCftLanguage.g:3195:2: ( ruleMappingDefinition )
+            // InternalCftLanguage.g:3196:3: ruleMappingDefinition
+            {
+             before(grammarAccess.getTransformationDefinitionAccess().getMappingDefinitionsMappingDefinitionParserRuleCall_3_0()); 
+            pushFollow(FOLLOW_2);
+            ruleMappingDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getTransformationDefinitionAccess().getMappingDefinitionsMappingDefinitionParserRuleCall_3_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__TransformationDefinition__MappingDefinitionsAssignment_3"
+
+
+    // $ANTLR start "rule__MappingDefinition__TopLevelAssignment_0"
+    // InternalCftLanguage.g:3205:1: rule__MappingDefinition__TopLevelAssignment_0 : ( ( 'toplevel' ) ) ;
+    public final void rule__MappingDefinition__TopLevelAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3209:1: ( ( ( 'toplevel' ) ) )
+            // InternalCftLanguage.g:3210:2: ( ( 'toplevel' ) )
+            {
+            // InternalCftLanguage.g:3210:2: ( ( 'toplevel' ) )
+            // InternalCftLanguage.g:3211:3: ( 'toplevel' )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getTopLevelToplevelKeyword_0_0()); 
+            // InternalCftLanguage.g:3212:3: ( 'toplevel' )
+            // InternalCftLanguage.g:3213:4: 'toplevel'
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getTopLevelToplevelKeyword_0_0()); 
+            match(input,36,FOLLOW_2); 
+             after(grammarAccess.getMappingDefinitionAccess().getTopLevelToplevelKeyword_0_0()); 
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getTopLevelToplevelKeyword_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__TopLevelAssignment_0"
+
+
+    // $ANTLR start "rule__MappingDefinition__PatternAssignment_2"
+    // InternalCftLanguage.g:3224:1: rule__MappingDefinition__PatternAssignment_2 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__MappingDefinition__PatternAssignment_2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3228:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalCftLanguage.g:3229:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalCftLanguage.g:3229:2: ( ( ruleQualifiedName ) )
+            // InternalCftLanguage.g:3230:3: ( ruleQualifiedName )
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getPatternPatternCrossReference_2_0()); 
+            // InternalCftLanguage.g:3231:3: ( ruleQualifiedName )
+            // InternalCftLanguage.g:3232:4: ruleQualifiedName
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getPatternPatternQualifiedNameParserRuleCall_2_0_1()); 
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionAccess().getPatternPatternQualifiedNameParserRuleCall_2_0_1()); 
+
+            }
+
+             after(grammarAccess.getMappingDefinitionAccess().getPatternPatternCrossReference_2_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__PatternAssignment_2"
+
+
+    // $ANTLR start "rule__MappingDefinition__ParametersAssignment_4"
+    // InternalCftLanguage.g:3243:1: rule__MappingDefinition__ParametersAssignment_4 : ( ruleMappingParameter ) ;
+    public final void rule__MappingDefinition__ParametersAssignment_4() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3247:1: ( ( ruleMappingParameter ) )
+            // InternalCftLanguage.g:3248:2: ( ruleMappingParameter )
+            {
+            // InternalCftLanguage.g:3248:2: ( ruleMappingParameter )
+            // InternalCftLanguage.g:3249:3: ruleMappingParameter
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getParametersMappingParameterParserRuleCall_4_0()); 
+            pushFollow(FOLLOW_2);
+            ruleMappingParameter();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionAccess().getParametersMappingParameterParserRuleCall_4_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__ParametersAssignment_4"
+
+
+    // $ANTLR start "rule__MappingDefinition__ParametersAssignment_5_1"
+    // InternalCftLanguage.g:3258:1: rule__MappingDefinition__ParametersAssignment_5_1 : ( ruleMappingParameter ) ;
+    public final void rule__MappingDefinition__ParametersAssignment_5_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3262:1: ( ( ruleMappingParameter ) )
+            // InternalCftLanguage.g:3263:2: ( ruleMappingParameter )
+            {
+            // InternalCftLanguage.g:3263:2: ( ruleMappingParameter )
+            // InternalCftLanguage.g:3264:3: ruleMappingParameter
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getParametersMappingParameterParserRuleCall_5_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleMappingParameter();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionAccess().getParametersMappingParameterParserRuleCall_5_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__ParametersAssignment_5_1"
+
+
+    // $ANTLR start "rule__MappingDefinition__ComponentInstanceAssignment_7"
+    // InternalCftLanguage.g:3273:1: rule__MappingDefinition__ComponentInstanceAssignment_7 : ( ruleComponentInstance ) ;
+    public final void rule__MappingDefinition__ComponentInstanceAssignment_7() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3277:1: ( ( ruleComponentInstance ) )
+            // InternalCftLanguage.g:3278:2: ( ruleComponentInstance )
+            {
+            // InternalCftLanguage.g:3278:2: ( ruleComponentInstance )
+            // InternalCftLanguage.g:3279:3: ruleComponentInstance
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getComponentInstanceComponentInstanceParserRuleCall_7_0()); 
+            pushFollow(FOLLOW_2);
+            ruleComponentInstance();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionAccess().getComponentInstanceComponentInstanceParserRuleCall_7_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__ComponentInstanceAssignment_7"
+
+
+    // $ANTLR start "rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0"
+    // InternalCftLanguage.g:3288:1: rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0 : ( ruleLookupDefinition ) ;
+    public final void rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3292:1: ( ( ruleLookupDefinition ) )
+            // InternalCftLanguage.g:3293:2: ( ruleLookupDefinition )
+            {
+            // InternalCftLanguage.g:3293:2: ( ruleLookupDefinition )
+            // InternalCftLanguage.g:3294:3: ruleLookupDefinition
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getLookupDefinitionsLookupDefinitionParserRuleCall_8_1_0_0_0()); 
+            pushFollow(FOLLOW_2);
+            ruleLookupDefinition();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionAccess().getLookupDefinitionsLookupDefinitionParserRuleCall_8_1_0_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__LookupDefinitionsAssignment_8_1_0_0"
+
+
+    // $ANTLR start "rule__MappingDefinition__AssignmentsAssignment_8_1_0_1"
+    // InternalCftLanguage.g:3303:1: rule__MappingDefinition__AssignmentsAssignment_8_1_0_1 : ( ruleAssignment ) ;
+    public final void rule__MappingDefinition__AssignmentsAssignment_8_1_0_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3307:1: ( ( ruleAssignment ) )
+            // InternalCftLanguage.g:3308:2: ( ruleAssignment )
+            {
+            // InternalCftLanguage.g:3308:2: ( ruleAssignment )
+            // InternalCftLanguage.g:3309:3: ruleAssignment
+            {
+             before(grammarAccess.getMappingDefinitionAccess().getAssignmentsAssignmentParserRuleCall_8_1_0_1_0()); 
+            pushFollow(FOLLOW_2);
+            ruleAssignment();
+
+            state._fsp--;
+
+             after(grammarAccess.getMappingDefinitionAccess().getAssignmentsAssignmentParserRuleCall_8_1_0_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingDefinition__AssignmentsAssignment_8_1_0_1"
+
+
+    // $ANTLR start "rule__MappingParameter__NameAssignment"
+    // InternalCftLanguage.g:3318:1: rule__MappingParameter__NameAssignment : ( RULE_ID ) ;
+    public final void rule__MappingParameter__NameAssignment() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3322:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3323:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3323:2: ( RULE_ID )
+            // InternalCftLanguage.g:3324:3: RULE_ID
+            {
+             before(grammarAccess.getMappingParameterAccess().getNameIDTerminalRuleCall_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getMappingParameterAccess().getNameIDTerminalRuleCall_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__MappingParameter__NameAssignment"
+
+
+    // $ANTLR start "rule__LookupDefinition__MappingAssignment_1"
+    // InternalCftLanguage.g:3333:1: rule__LookupDefinition__MappingAssignment_1 : ( ( RULE_ID ) ) ;
+    public final void rule__LookupDefinition__MappingAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3337:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3338:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3338:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3339:3: ( RULE_ID )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getMappingMappingDefinitionCrossReference_1_0()); 
+            // InternalCftLanguage.g:3340:3: ( RULE_ID )
+            // InternalCftLanguage.g:3341:4: RULE_ID
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getMappingMappingDefinitionIDTerminalRuleCall_1_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getMappingMappingDefinitionIDTerminalRuleCall_1_0_1()); 
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getMappingMappingDefinitionCrossReference_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__MappingAssignment_1"
+
+
+    // $ANTLR start "rule__LookupDefinition__ArgumentsAssignment_3"
+    // InternalCftLanguage.g:3352:1: rule__LookupDefinition__ArgumentsAssignment_3 : ( ( RULE_ID ) ) ;
+    public final void rule__LookupDefinition__ArgumentsAssignment_3() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3356:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3357:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3357:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3358:3: ( RULE_ID )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterCrossReference_3_0()); 
+            // InternalCftLanguage.g:3359:3: ( RULE_ID )
+            // InternalCftLanguage.g:3360:4: RULE_ID
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterIDTerminalRuleCall_3_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterIDTerminalRuleCall_3_0_1()); 
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterCrossReference_3_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__ArgumentsAssignment_3"
+
+
+    // $ANTLR start "rule__LookupDefinition__ArgumentsAssignment_4_1"
+    // InternalCftLanguage.g:3371:1: rule__LookupDefinition__ArgumentsAssignment_4_1 : ( ( RULE_ID ) ) ;
+    public final void rule__LookupDefinition__ArgumentsAssignment_4_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3375:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3376:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3376:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3377:3: ( RULE_ID )
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterCrossReference_4_1_0()); 
+            // InternalCftLanguage.g:3378:3: ( RULE_ID )
+            // InternalCftLanguage.g:3379:4: RULE_ID
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterIDTerminalRuleCall_4_1_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterIDTerminalRuleCall_4_1_0_1()); 
+
+            }
+
+             after(grammarAccess.getLookupDefinitionAccess().getArgumentsMappingParameterCrossReference_4_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__ArgumentsAssignment_4_1"
+
+
+    // $ANTLR start "rule__LookupDefinition__NameAssignment_7"
+    // InternalCftLanguage.g:3390:1: rule__LookupDefinition__NameAssignment_7 : ( RULE_ID ) ;
+    public final void rule__LookupDefinition__NameAssignment_7() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3394:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3395:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3395:2: ( RULE_ID )
+            // InternalCftLanguage.g:3396:3: RULE_ID
+            {
+             before(grammarAccess.getLookupDefinitionAccess().getNameIDTerminalRuleCall_7_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getLookupDefinitionAccess().getNameIDTerminalRuleCall_7_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__LookupDefinition__NameAssignment_7"
+
+
+    // $ANTLR start "rule__Assignment__InputAssignment_0"
+    // InternalCftLanguage.g:3405:1: rule__Assignment__InputAssignment_0 : ( ruleEventReference ) ;
+    public final void rule__Assignment__InputAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3409:1: ( ( ruleEventReference ) )
+            // InternalCftLanguage.g:3410:2: ( ruleEventReference )
+            {
+            // InternalCftLanguage.g:3410:2: ( ruleEventReference )
+            // InternalCftLanguage.g:3411:3: ruleEventReference
+            {
+             before(grammarAccess.getAssignmentAccess().getInputEventReferenceParserRuleCall_0_0()); 
+            pushFollow(FOLLOW_2);
+            ruleEventReference();
+
+            state._fsp--;
+
+             after(grammarAccess.getAssignmentAccess().getInputEventReferenceParserRuleCall_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__InputAssignment_0"
+
+
+    // $ANTLR start "rule__Assignment__MultipleAssignment_1_0"
+    // InternalCftLanguage.g:3420:1: rule__Assignment__MultipleAssignment_1_0 : ( ( '+=' ) ) ;
+    public final void rule__Assignment__MultipleAssignment_1_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3424:1: ( ( ( '+=' ) ) )
+            // InternalCftLanguage.g:3425:2: ( ( '+=' ) )
+            {
+            // InternalCftLanguage.g:3425:2: ( ( '+=' ) )
+            // InternalCftLanguage.g:3426:3: ( '+=' )
+            {
+             before(grammarAccess.getAssignmentAccess().getMultiplePlusSignEqualsSignKeyword_1_0_0()); 
+            // InternalCftLanguage.g:3427:3: ( '+=' )
+            // InternalCftLanguage.g:3428:4: '+='
+            {
+             before(grammarAccess.getAssignmentAccess().getMultiplePlusSignEqualsSignKeyword_1_0_0()); 
+            match(input,37,FOLLOW_2); 
+             after(grammarAccess.getAssignmentAccess().getMultiplePlusSignEqualsSignKeyword_1_0_0()); 
+
+            }
+
+             after(grammarAccess.getAssignmentAccess().getMultiplePlusSignEqualsSignKeyword_1_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__MultipleAssignment_1_0"
+
+
+    // $ANTLR start "rule__Assignment__OutputAssignment_2"
+    // InternalCftLanguage.g:3439:1: rule__Assignment__OutputAssignment_2 : ( ruleEventReference ) ;
+    public final void rule__Assignment__OutputAssignment_2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3443:1: ( ( ruleEventReference ) )
+            // InternalCftLanguage.g:3444:2: ( ruleEventReference )
+            {
+            // InternalCftLanguage.g:3444:2: ( ruleEventReference )
+            // InternalCftLanguage.g:3445:3: ruleEventReference
+            {
+             before(grammarAccess.getAssignmentAccess().getOutputEventReferenceParserRuleCall_2_0()); 
+            pushFollow(FOLLOW_2);
+            ruleEventReference();
+
+            state._fsp--;
+
+             after(grammarAccess.getAssignmentAccess().getOutputEventReferenceParserRuleCall_2_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Assignment__OutputAssignment_2"
+
+
+    // $ANTLR start "rule__EventReference__ComponentAssignment_0"
+    // InternalCftLanguage.g:3454:1: rule__EventReference__ComponentAssignment_0 : ( ( RULE_ID ) ) ;
+    public final void rule__EventReference__ComponentAssignment_0() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3458:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3459:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3459:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3460:3: ( RULE_ID )
+            {
+             before(grammarAccess.getEventReferenceAccess().getComponentVariableCrossReference_0_0()); 
+            // InternalCftLanguage.g:3461:3: ( RULE_ID )
+            // InternalCftLanguage.g:3462:4: RULE_ID
+            {
+             before(grammarAccess.getEventReferenceAccess().getComponentVariableIDTerminalRuleCall_0_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getEventReferenceAccess().getComponentVariableIDTerminalRuleCall_0_0_1()); 
+
+            }
+
+             after(grammarAccess.getEventReferenceAccess().getComponentVariableCrossReference_0_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__ComponentAssignment_0"
+
+
+    // $ANTLR start "rule__EventReference__EventAssignment_2"
+    // InternalCftLanguage.g:3473:1: rule__EventReference__EventAssignment_2 : ( ( RULE_ID ) ) ;
+    public final void rule__EventReference__EventAssignment_2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3477:1: ( ( ( RULE_ID ) ) )
+            // InternalCftLanguage.g:3478:2: ( ( RULE_ID ) )
+            {
+            // InternalCftLanguage.g:3478:2: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3479:3: ( RULE_ID )
+            {
+             before(grammarAccess.getEventReferenceAccess().getEventEventDeclarationCrossReference_2_0()); 
+            // InternalCftLanguage.g:3480:3: ( RULE_ID )
+            // InternalCftLanguage.g:3481:4: RULE_ID
+            {
+             before(grammarAccess.getEventReferenceAccess().getEventEventDeclarationIDTerminalRuleCall_2_0_1()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getEventReferenceAccess().getEventEventDeclarationIDTerminalRuleCall_2_0_1()); 
+
+            }
+
+             after(grammarAccess.getEventReferenceAccess().getEventEventDeclarationCrossReference_2_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__EventReference__EventAssignment_2"
+
+
+    // $ANTLR start "rule__ComponentInstance__ComponentTypeAssignment_1"
+    // InternalCftLanguage.g:3492:1: rule__ComponentInstance__ComponentTypeAssignment_1 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__ComponentInstance__ComponentTypeAssignment_1() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3496:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalCftLanguage.g:3497:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalCftLanguage.g:3497:2: ( ( ruleQualifiedName ) )
+            // InternalCftLanguage.g:3498:3: ( ruleQualifiedName )
+            {
+             before(grammarAccess.getComponentInstanceAccess().getComponentTypeComponentDefinitionCrossReference_1_0()); 
+            // InternalCftLanguage.g:3499:3: ( ruleQualifiedName )
+            // InternalCftLanguage.g:3500:4: ruleQualifiedName
+            {
+             before(grammarAccess.getComponentInstanceAccess().getComponentTypeComponentDefinitionQualifiedNameParserRuleCall_1_0_1()); 
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+
+             after(grammarAccess.getComponentInstanceAccess().getComponentTypeComponentDefinitionQualifiedNameParserRuleCall_1_0_1()); 
+
+            }
+
+             after(grammarAccess.getComponentInstanceAccess().getComponentTypeComponentDefinitionCrossReference_1_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__ComponentTypeAssignment_1"
+
+
+    // $ANTLR start "rule__ComponentInstance__NameAssignment_2"
+    // InternalCftLanguage.g:3511:1: rule__ComponentInstance__NameAssignment_2 : ( RULE_ID ) ;
+    public final void rule__ComponentInstance__NameAssignment_2() throws RecognitionException {
+
+                        int stackSize = keepStackSize();
+                
+        try {
+            // InternalCftLanguage.g:3515:1: ( ( RULE_ID ) )
+            // InternalCftLanguage.g:3516:2: ( RULE_ID )
+            {
+            // InternalCftLanguage.g:3516:2: ( RULE_ID )
+            // InternalCftLanguage.g:3517:3: RULE_ID
+            {
+             before(grammarAccess.getComponentInstanceAccess().getNameIDTerminalRuleCall_2_0()); 
+            match(input,RULE_ID,FOLLOW_2); 
+             after(grammarAccess.getComponentInstanceAccess().getNameIDTerminalRuleCall_2_0()); 
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+                restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ComponentInstance__NameAssignment_2"
+
+    // Delegated rules
+
+
+ 
+
+    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[]{0x0000000000000010L});
+    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x000000000201C000L});
+    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000008002L});
+    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000002010002L});
+    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000004000L});
+    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000020000L});
+    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000180000L});
+    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000040010L});
+    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000012L});
+    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000004010L});
+    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000800000000L});
+    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000200000L});
+    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000400000L});
+    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000020L});
+    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000800000L});
+    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000001000000L});
+    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000001004040000L});
+    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000001004000002L});
+    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000001004000000L});
+    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000008000000L});
+    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000030000000L});
+    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000020000002L});
+    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000200020000L});
+    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000040040010L});
+    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000040000012L});
+    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000080000000L});
+    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000002000001000L});
+    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000040000010L});
+    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000100000000L});
+    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000100000002L});
+    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000400000000L});
+    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000180002L});
+
+}