nemo-tools/eclipse-plugin/nemo-editor/org.opendaylight.nemo.tool.eclipse.plugin.editor.ui/bin/org/opendaylight/nemo/tool/eclipse/plugin/ui/contentassist/antlr/internal/InternalEditor.g

   1 /*
   2  * generated by Xtext
   3  */
   4 grammar InternalEditor;
   5
   6 options {
   7         superClass=AbstractInternalContentAssistParser;
   8
   9 }
  10
  11 @lexer::header {
  12 package org.opendaylight.nemo.tool.eclipse.plugin.ui.contentassist.antlr.internal;
  13
  14 // Hack: Use our own Lexer superclass by means of import.
  15 // Currently there is no other way to specify the superclass for the lexer.
  16 import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer;
  17 }
  18
  19 @parser::header {
  20 package org.opendaylight.nemo.tool.eclipse.plugin.ui.contentassist.antlr.internal;
  21
  22 import java.io.InputStream;
  23 import org.eclipse.xtext.*;
  24 import org.eclipse.xtext.parser.*;
  25 import org.eclipse.xtext.parser.impl.*;
  26 import org.eclipse.emf.ecore.util.EcoreUtil;
  27 import org.eclipse.emf.ecore.EObject;
  28 import org.eclipse.xtext.parser.antlr.XtextTokenStream;
  29 import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
  30 import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
  31 import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
  32 import org.opendaylight.nemo.tool.eclipse.plugin.services.EditorGrammarAccess;
  33
  34 }
  35
  36 @parser::members {
  37
  38         private EditorGrammarAccess grammarAccess;
  39
  40     public void setGrammarAccess(EditorGrammarAccess grammarAccess) {
  41         this.grammarAccess = grammarAccess;
  42     }
  43
  44     @Override
  45     protected Grammar getGrammar() {
  46         return grammarAccess.getGrammar();
  47     }
  48
  49     @Override
  50     protected String getValueForTokenName(String tokenName) {
  51         return tokenName;
  52     }
  53
  54 }
  55
  56
  57
  58
  59 // Entry rule entryRuleModel
  60 entryRuleModel
  61 :
  62 { before(grammarAccess.getModelRule()); }
  63          ruleModel
  64 { after(grammarAccess.getModelRule()); }
  65          EOF
  66 ;
  67
  68 // Rule Model
  69 ruleModel
  70     @init {
  71                 int stackSize = keepStackSize();
  72     }
  73         :
  74 (
  75 { before(grammarAccess.getModelAccess().getSentencesAssignment()); }
  76 (rule__Model__SentencesAssignment)*
  77 { after(grammarAccess.getModelAccess().getSentencesAssignment()); }
  78 )
  79
  80 ;
  81 finally {
  82         restoreStackSize(stackSize);
  83 }
  84
  85
  86
  87 // Entry rule entryRuleSentence
  88 entryRuleSentence
  89 :
  90 { before(grammarAccess.getSentenceRule()); }
  91          ruleSentence
  92 { after(grammarAccess.getSentenceRule()); }
  93          EOF
  94 ;
  95
  96 // Rule Sentence
  97 ruleSentence
  98     @init {
  99                 int stackSize = keepStackSize();
 100     }
 101         :
 102 (
 103 { before(grammarAccess.getSentenceAccess().getAlternatives()); }
 104 (rule__Sentence__Alternatives)
 105 { after(grammarAccess.getSentenceAccess().getAlternatives()); }
 106 )
 107
 108 ;
 109 finally {
 110         restoreStackSize(stackSize);
 111 }
 112
 113
 114
 115 // Entry rule entryRuleSenEngines
 116 entryRuleSenEngines
 117 :
 118 { before(grammarAccess.getSenEnginesRule()); }
 119          ruleSenEngines
 120 { after(grammarAccess.getSenEnginesRule()); }
 121          EOF
 122 ;
 123
 124 // Rule SenEngines
 125 ruleSenEngines
 126     @init {
 127                 int stackSize = keepStackSize();
 128     }
 129         :
 130 (
 131 { before(grammarAccess.getSenEnginesAccess().getGroup()); }
 132 (rule__SenEngines__Group__0)
 133 { after(grammarAccess.getSenEnginesAccess().getGroup()); }
 134 )
 135
 136 ;
 137 finally {
 138         restoreStackSize(stackSize);
 139 }
 140
 141
 142
 143 // Entry rule entryRuleIpv4
 144 entryRuleIpv4
 145 :
 146 { before(grammarAccess.getIpv4Rule()); }
 147          ruleIpv4
 148 { after(grammarAccess.getIpv4Rule()); }
 149          EOF
 150 ;
 151
 152 // Rule Ipv4
 153 ruleIpv4
 154     @init {
 155                 int stackSize = keepStackSize();
 156     }
 157         :
 158 (
 159 { before(grammarAccess.getIpv4Access().getGroup()); }
 160 (rule__Ipv4__Group__0)
 161 { after(grammarAccess.getIpv4Access().getGroup()); }
 162 )
 163
 164 ;
 165 finally {
 166         restoreStackSize(stackSize);
 167 }
 168
 169
 170
 171 // Entry rule entryRuleUser
 172 entryRuleUser
 173 :
 174 { before(grammarAccess.getUserRule()); }
 175          ruleUser
 176 { after(grammarAccess.getUserRule()); }
 177          EOF
 178 ;
 179
 180 // Rule User
 181 ruleUser
 182     @init {
 183                 int stackSize = keepStackSize();
 184     }
 185         :
 186 (
 187 { before(grammarAccess.getUserAccess().getGroup()); }
 188 (rule__User__Group__0)
 189 { after(grammarAccess.getUserAccess().getGroup()); }
 190 )
 191
 192 ;
 193 finally {
 194         restoreStackSize(stackSize);
 195 }
 196
 197
 198
 199 // Entry rule entryRuleNode
 200 entryRuleNode
 201 :
 202 { before(grammarAccess.getNodeRule()); }
 203          ruleNode
 204 { after(grammarAccess.getNodeRule()); }
 205          EOF
 206 ;
 207
 208 // Rule Node
 209 ruleNode
 210     @init {
 211                 int stackSize = keepStackSize();
 212     }
 213         :
 214 (
 215 { before(grammarAccess.getNodeAccess().getGroup()); }
 216 (rule__Node__Group__0)
 217 { after(grammarAccess.getNodeAccess().getGroup()); }
 218 )
 219
 220 ;
 221 finally {
 222         restoreStackSize(stackSize);
 223 }
 224
 225
 226
 227
 228
 229 // Entry rule entryRuleNodeOperating
 230 entryRuleNodeOperating
 231 :
 232 { before(grammarAccess.getNodeOperatingRule()); }
 233          ruleNodeOperating
 234 { after(grammarAccess.getNodeOperatingRule()); }
 235          EOF
 236 ;
 237
 238 // Rule NodeOperating
 239 ruleNodeOperating
 240     @init {
 241                 int stackSize = keepStackSize();
 242     }
 243         :
 244 (
 245 { before(grammarAccess.getNodeOperatingAccess().getGroup()); }
 246 (rule__NodeOperating__Group__0)
 247 { after(grammarAccess.getNodeOperatingAccess().getGroup()); }
 248 )
 249
 250 ;
 251 finally {
 252         restoreStackSize(stackSize);
 253 }
 254
 255
 256
 257 // Entry rule entryRuleConnection
 258 entryRuleConnection
 259 :
 260 { before(grammarAccess.getConnectionRule()); }
 261          ruleConnection
 262 { after(grammarAccess.getConnectionRule()); }
 263          EOF
 264 ;
 265
 266 // Rule Connection
 267 ruleConnection
 268     @init {
 269                 int stackSize = keepStackSize();
 270     }
 271         :
 272 (
 273 { before(grammarAccess.getConnectionAccess().getGroup()); }
 274 (rule__Connection__Group__0)
 275 { after(grammarAccess.getConnectionAccess().getGroup()); }
 276 )
 277
 278 ;
 279 finally {
 280         restoreStackSize(stackSize);
 281 }
 282
 283
 284
 285 // Entry rule entryRuleConnectionUpdate
 286 entryRuleConnectionUpdate
 287 :
 288 { before(grammarAccess.getConnectionUpdateRule()); }
 289          ruleConnectionUpdate
 290 { after(grammarAccess.getConnectionUpdateRule()); }
 291          EOF
 292 ;
 293
 294 // Rule ConnectionUpdate
 295 ruleConnectionUpdate
 296     @init {
 297                 int stackSize = keepStackSize();
 298     }
 299         :
 300 (
 301 { before(grammarAccess.getConnectionUpdateAccess().getGroup()); }
 302 (rule__ConnectionUpdate__Group__0)
 303 { after(grammarAccess.getConnectionUpdateAccess().getGroup()); }
 304 )
 305
 306 ;
 307 finally {
 308         restoreStackSize(stackSize);
 309 }
 310
 311
 312
 313 // Entry rule entryRuleFlow
 314 entryRuleFlow
 315 :
 316 { before(grammarAccess.getFlowRule()); }
 317          ruleFlow
 318 { after(grammarAccess.getFlowRule()); }
 319          EOF
 320 ;
 321
 322 // Rule Flow
 323 ruleFlow
 324     @init {
 325                 int stackSize = keepStackSize();
 326     }
 327         :
 328 (
 329 { before(grammarAccess.getFlowAccess().getGroup()); }
 330 (rule__Flow__Group__0)
 331 { after(grammarAccess.getFlowAccess().getGroup()); }
 332 )
 333
 334 ;
 335 finally {
 336         restoreStackSize(stackSize);
 337 }
 338
 339
 340
 341 // Entry rule entryRuleFlowUpdate
 342 entryRuleFlowUpdate
 343 :
 344 { before(grammarAccess.getFlowUpdateRule()); }
 345          ruleFlowUpdate
 346 { after(grammarAccess.getFlowUpdateRule()); }
 347          EOF
 348 ;
 349
 350 // Rule FlowUpdate
 351 ruleFlowUpdate
 352     @init {
 353                 int stackSize = keepStackSize();
 354     }
 355         :
 356 (
 357 { before(grammarAccess.getFlowUpdateAccess().getGroup()); }
 358 (rule__FlowUpdate__Group__0)
 359 { after(grammarAccess.getFlowUpdateAccess().getGroup()); }
 360 )
 361
 362 ;
 363 finally {
 364         restoreStackSize(stackSize);
 365 }
 366
 367
 368
 369 // Entry rule entryRuleMatches
 370 entryRuleMatches
 371 :
 372 { before(grammarAccess.getMatchesRule()); }
 373          ruleMatches
 374 { after(grammarAccess.getMatchesRule()); }
 375          EOF
 376 ;
 377
 378 // Rule Matches
 379 ruleMatches
 380     @init {
 381                 int stackSize = keepStackSize();
 382     }
 383         :
 384 (
 385 { before(grammarAccess.getMatchesAccess().getGroup()); }
 386 (rule__Matches__Group__0)
 387 { after(grammarAccess.getMatchesAccess().getGroup()); }
 388 )
 389
 390 ;
 391 finally {
 392         restoreStackSize(stackSize);
 393 }
 394
 395
 396
 397 // Entry rule entryRuleMatch
 398 entryRuleMatch
 399 :
 400 { before(grammarAccess.getMatchRule()); }
 401          ruleMatch
 402 { after(grammarAccess.getMatchRule()); }
 403          EOF
 404 ;
 405
 406 // Rule Match
 407 ruleMatch
 408     @init {
 409                 int stackSize = keepStackSize();
 410     }
 411         :
 412 (
 413 { before(grammarAccess.getMatchAccess().getGroup()); }
 414 (rule__Match__Group__0)
 415 { after(grammarAccess.getMatchAccess().getGroup()); }
 416 )
 417
 418 ;
 419 finally {
 420         restoreStackSize(stackSize);
 421 }
 422
 423
 424
 425 // Entry rule entryRuleOperation
 426 entryRuleOperation
 427 :
 428 { before(grammarAccess.getOperationRule()); }
 429          ruleOperation
 430 { after(grammarAccess.getOperationRule()); }
 431          EOF
 432 ;
 433
 434 // Rule Operation
 435 ruleOperation
 436     @init {
 437                 int stackSize = keepStackSize();
 438     }
 439         :
 440 (
 441 { before(grammarAccess.getOperationAccess().getGroup()); }
 442 (rule__Operation__Group__0)
 443 { after(grammarAccess.getOperationAccess().getGroup()); }
 444 )
 445
 446 ;
 447 finally {
 448         restoreStackSize(stackSize);
 449 }
 450
 451
 452
 453 // Entry rule entryRuleCondition
 454 entryRuleCondition
 455 :
 456 { before(grammarAccess.getConditionRule()); }
 457          ruleCondition
 458 { after(grammarAccess.getConditionRule()); }
 459          EOF
 460 ;
 461
 462 // Rule Condition
 463 ruleCondition
 464     @init {
 465                 int stackSize = keepStackSize();
 466     }
 467         :
 468 (
 469 { before(grammarAccess.getConditionAccess().getGroup()); }
 470 (rule__Condition__Group__0)
 471 { after(grammarAccess.getConditionAccess().getGroup()); }
 472 )
 473
 474 ;
 475 finally {
 476         restoreStackSize(stackSize);
 477 }
 478
 479
 480
 481 // Entry rule entryRuleProperty
 482 entryRuleProperty
 483 :
 484 { before(grammarAccess.getPropertyRule()); }
 485          ruleProperty
 486 { after(grammarAccess.getPropertyRule()); }
 487          EOF
 488 ;
 489
 490 // Rule Property
 491 ruleProperty
 492     @init {
 493                 int stackSize = keepStackSize();
 494     }
 495         :
 496 (
 497 { before(grammarAccess.getPropertyAccess().getGroup()); }
 498 (rule__Property__Group__0)
 499 { after(grammarAccess.getPropertyAccess().getGroup()); }
 500 )
 501
 502 ;
 503 finally {
 504         restoreStackSize(stackSize);
 505 }
 506
 507
 508
 509 // Entry rule entryRuleOneProperty
 510 entryRuleOneProperty
 511 :
 512 { before(grammarAccess.getOnePropertyRule()); }
 513          ruleOneProperty
 514 { after(grammarAccess.getOnePropertyRule()); }
 515          EOF
 516 ;
 517
 518 // Rule OneProperty
 519 ruleOneProperty
 520     @init {
 521                 int stackSize = keepStackSize();
 522     }
 523         :
 524 (
 525 { before(grammarAccess.getOnePropertyAccess().getGroup()); }
 526 (rule__OneProperty__Group__0)
 527 { after(grammarAccess.getOnePropertyAccess().getGroup()); }
 528 )
 529
 530 ;
 531 finally {
 532         restoreStackSize(stackSize);
 533 }
 534
 535
 536
 537 // Entry rule entryRuleModelProperty
 538 entryRuleModelProperty
 539 :
 540 { before(grammarAccess.getModelPropertyRule()); }
 541          ruleModelProperty
 542 { after(grammarAccess.getModelPropertyRule()); }
 543          EOF
 544 ;
 545
 546 // Rule ModelProperty
 547 ruleModelProperty
 548     @init {
 549                 int stackSize = keepStackSize();
 550     }
 551         :
 552 (
 553 { before(grammarAccess.getModelPropertyAccess().getGroup()); }
 554 (rule__ModelProperty__Group__0)
 555 { after(grammarAccess.getModelPropertyAccess().getGroup()); }
 556 )
 557
 558 ;
 559 finally {
 560         restoreStackSize(stackSize);
 561 }
 562
 563
 564
 565 // Entry rule entryRuleOneModelProperty
 566 entryRuleOneModelProperty
 567 :
 568 { before(grammarAccess.getOneModelPropertyRule()); }
 569          ruleOneModelProperty
 570 { after(grammarAccess.getOneModelPropertyRule()); }
 571          EOF
 572 ;
 573
 574 // Rule OneModelProperty
 575 ruleOneModelProperty
 576     @init {
 577                 int stackSize = keepStackSize();
 578     }
 579         :
 580 (
 581 { before(grammarAccess.getOneModelPropertyAccess().getGroup()); }
 582 (rule__OneModelProperty__Group__0)
 583 { after(grammarAccess.getOneModelPropertyAccess().getGroup()); }
 584 )
 585
 586 ;
 587 finally {
 588         restoreStackSize(stackSize);
 589 }
 590
 591
 592
 593 // Entry rule entryRuleNewObj
 594 entryRuleNewObj
 595 :
 596 { before(grammarAccess.getNewObjRule()); }
 597          ruleNewObj
 598 { after(grammarAccess.getNewObjRule()); }
 599          EOF
 600 ;
 601
 602 // Rule NewObj
 603 ruleNewObj
 604     @init {
 605                 int stackSize = keepStackSize();
 606     }
 607         :
 608 (
 609 { before(grammarAccess.getNewObjAccess().getAlternatives()); }
 610 (rule__NewObj__Alternatives)
 611 { after(grammarAccess.getNewObjAccess().getAlternatives()); }
 612 )
 613
 614 ;
 615 finally {
 616         restoreStackSize(stackSize);
 617 }
 618
 619
 620
 621
 622 rule__Sentence__Alternatives
 623     @init {
 624                 int stackSize = keepStackSize();
 625     }
 626 :
 627 (
 628 { before(grammarAccess.getSentenceAccess().getSenEnginesParserRuleCall_0()); }
 629         ruleSenEngines
 630 { after(grammarAccess.getSentenceAccess().getSenEnginesParserRuleCall_0()); }
 631 )
 632
 633     |(
 634 { before(grammarAccess.getSentenceAccess().getUserParserRuleCall_1()); }
 635         ruleUser
 636 { after(grammarAccess.getSentenceAccess().getUserParserRuleCall_1()); }
 637 )
 638
 639     |(
 640 { before(grammarAccess.getSentenceAccess().getNodeParserRuleCall_2()); }
 641         ruleNode
 642 { after(grammarAccess.getSentenceAccess().getNodeParserRuleCall_2()); }
 643 )
 644
 645     |(
 646 { before(grammarAccess.getSentenceAccess().getNodeOperatingParserRuleCall_3()); }
 647         ruleNodeOperating
 648 { after(grammarAccess.getSentenceAccess().getNodeOperatingParserRuleCall_3()); }
 649 )
 650
 651     |(
 652 { before(grammarAccess.getSentenceAccess().getConnectionParserRuleCall_4()); }
 653         ruleConnection
 654 { after(grammarAccess.getSentenceAccess().getConnectionParserRuleCall_4()); }
 655 )
 656
 657     |(
 658 { before(grammarAccess.getSentenceAccess().getConnectionUpdateParserRuleCall_5()); }
 659         ruleConnectionUpdate
 660 { after(grammarAccess.getSentenceAccess().getConnectionUpdateParserRuleCall_5()); }
 661 )
 662
 663     |(
 664 { before(grammarAccess.getSentenceAccess().getFlowParserRuleCall_6()); }
 665         ruleFlow
 666 { after(grammarAccess.getSentenceAccess().getFlowParserRuleCall_6()); }
 667 )
 668
 669     |(
 670 { before(grammarAccess.getSentenceAccess().getFlowUpdateParserRuleCall_7()); }
 671         ruleFlowUpdate
 672 { after(grammarAccess.getSentenceAccess().getFlowUpdateParserRuleCall_7()); }
 673 )
 674
 675     |(
 676 { before(grammarAccess.getSentenceAccess().getOperationParserRuleCall_8()); }
 677         ruleOperation
 678 { after(grammarAccess.getSentenceAccess().getOperationParserRuleCall_8()); }
 679 )
 680
 681 ;
 682 finally {
 683         restoreStackSize(stackSize);
 684 }
 685
 686 rule__NodeOperating__Alternatives_0
 687     @init {
 688                 int stackSize = keepStackSize();
 689     }
 690 :
 691 (
 692 { before(grammarAccess.getNodeOperatingAccess().getUPDATEKeyword_0_0()); }
 693
 694         'UPDATE'
 695
 696 { after(grammarAccess.getNodeOperatingAccess().getUPDATEKeyword_0_0()); }
 697 )
 698
 699     |(
 700 { before(grammarAccess.getNodeOperatingAccess().getDELETEKeyword_0_1()); }
 701
 702         'DELETE'
 703
 704 { after(grammarAccess.getNodeOperatingAccess().getDELETEKeyword_0_1()); }
 705 )
 706
 707 ;
 708 finally {
 709         restoreStackSize(stackSize);
 710 }
 711
 712 rule__ConnectionUpdate__Alternatives_0
 713     @init {
 714                 int stackSize = keepStackSize();
 715     }
 716 :
 717 (
 718 { before(grammarAccess.getConnectionUpdateAccess().getUPDATEKeyword_0_0()); }
 719
 720         'UPDATE'
 721
 722 { after(grammarAccess.getConnectionUpdateAccess().getUPDATEKeyword_0_0()); }
 723 )
 724
 725     |(
 726 { before(grammarAccess.getConnectionUpdateAccess().getDELETEKeyword_0_1()); }
 727
 728         'DELETE'
 729
 730 { after(grammarAccess.getConnectionUpdateAccess().getDELETEKeyword_0_1()); }
 731 )
 732
 733 ;
 734 finally {
 735         restoreStackSize(stackSize);
 736 }
 737
 738 rule__FlowUpdate__Alternatives_0
 739     @init {
 740                 int stackSize = keepStackSize();
 741     }
 742 :
 743 (
 744 { before(grammarAccess.getFlowUpdateAccess().getUPDATEKeyword_0_0()); }
 745
 746         'UPDATE'
 747
 748 { after(grammarAccess.getFlowUpdateAccess().getUPDATEKeyword_0_0()); }
 749 )
 750
 751     |(
 752 { before(grammarAccess.getFlowUpdateAccess().getDELETEKeyword_0_1()); }
 753
 754         'DELETE'
 755
 756 { after(grammarAccess.getFlowUpdateAccess().getDELETEKeyword_0_1()); }
 757 )
 758
 759 ;
 760 finally {
 761         restoreStackSize(stackSize);
 762 }
 763
 764 rule__Operation__Alternatives_8
 765     @init {
 766                 int stackSize = keepStackSize();
 767     }
 768 :
 769 (
 770 { before(grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_0()); }
 771         RULE_NEMOID
 772 { after(grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_0()); }
 773 )
 774
 775     |(
 776 { before(grammarAccess.getOperationAccess().getGroup_8_1()); }
 777 (rule__Operation__Group_8_1__0)
 778 { after(grammarAccess.getOperationAccess().getGroup_8_1()); }
 779 )
 780
 781 ;
 782 finally {
 783         restoreStackSize(stackSize);
 784 }
 785
 786 rule__OneProperty__Alternatives_2
 787     @init {
 788                 int stackSize = keepStackSize();
 789     }
 790 :
 791 (
 792 { before(grammarAccess.getOnePropertyAccess().getSTRINGTerminalRuleCall_2_0()); }
 793         RULE_STRING
 794 { after(grammarAccess.getOnePropertyAccess().getSTRINGTerminalRuleCall_2_0()); }
 795 )
 796
 797     |(
 798 { before(grammarAccess.getOnePropertyAccess().getINTTerminalRuleCall_2_1()); }
 799         RULE_INT
 800 { after(grammarAccess.getOnePropertyAccess().getINTTerminalRuleCall_2_1()); }
 801 )
 802
 803 ;
 804 finally {
 805         restoreStackSize(stackSize);
 806 }
 807
 808 rule__OneModelProperty__Alternatives_0
 809     @init {
 810                 int stackSize = keepStackSize();
 811     }
 812 :
 813 (
 814 { before(grammarAccess.getOneModelPropertyAccess().getSTRINGTerminalRuleCall_0_0()); }
 815         RULE_STRING
 816 { after(grammarAccess.getOneModelPropertyAccess().getSTRINGTerminalRuleCall_0_0()); }
 817 )
 818
 819     |(
 820 { before(grammarAccess.getOneModelPropertyAccess().getINTTerminalRuleCall_0_1()); }
 821         RULE_INT
 822 { after(grammarAccess.getOneModelPropertyAccess().getINTTerminalRuleCall_0_1()); }
 823 )
 824
 825 ;
 826 finally {
 827         restoreStackSize(stackSize);
 828 }
 829
 830 rule__NewObj__Alternatives
 831     @init {
 832                 int stackSize = keepStackSize();
 833     }
 834 :
 835 (
 836 { before(grammarAccess.getNewObjAccess().getCREATEKeyword_0()); }
 837
 838         'CREATE'
 839
 840 { after(grammarAccess.getNewObjAccess().getCREATEKeyword_0()); }
 841 )
 842
 843     |(
 844 { before(grammarAccess.getNewObjAccess().getIMPORTKeyword_1()); }
 845
 846         'IMPORT'
 847
 848 { after(grammarAccess.getNewObjAccess().getIMPORTKeyword_1()); }
 849 )
 850
 851 ;
 852 finally {
 853         restoreStackSize(stackSize);
 854 }
 855
 856
 857
 858 rule__SenEngines__Group__0
 859     @init {
 860                 int stackSize = keepStackSize();
 861     }
 862 :
 863         rule__SenEngines__Group__0__Impl
 864         rule__SenEngines__Group__1
 865 ;
 866 finally {
 867         restoreStackSize(stackSize);
 868 }
 869
 870 rule__SenEngines__Group__0__Impl
 871     @init {
 872                 int stackSize = keepStackSize();
 873     }
 874 :
 875 (
 876 { before(grammarAccess.getSenEnginesAccess().getEnginesKeyword_0()); }
 877
 878         'Engines:'
 879
 880 { after(grammarAccess.getSenEnginesAccess().getEnginesKeyword_0()); }
 881 )
 882
 883 ;
 884 finally {
 885         restoreStackSize(stackSize);
 886 }
 887
 888
 889 rule__SenEngines__Group__1
 890     @init {
 891                 int stackSize = keepStackSize();
 892     }
 893 :
 894         rule__SenEngines__Group__1__Impl
 895         rule__SenEngines__Group__2
 896 ;
 897 finally {
 898         restoreStackSize(stackSize);
 899 }
 900
 901 rule__SenEngines__Group__1__Impl
 902     @init {
 903                 int stackSize = keepStackSize();
 904     }
 905 :
 906 (
 907 { before(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_1()); }
 908         ruleIpv4
 909 { after(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_1()); }
 910 )
 911
 912 ;
 913 finally {
 914         restoreStackSize(stackSize);
 915 }
 916
 917
 918 rule__SenEngines__Group__2
 919     @init {
 920                 int stackSize = keepStackSize();
 921     }
 922 :
 923         rule__SenEngines__Group__2__Impl
 924         rule__SenEngines__Group__3
 925 ;
 926 finally {
 927         restoreStackSize(stackSize);
 928 }
 929
 930 rule__SenEngines__Group__2__Impl
 931     @init {
 932                 int stackSize = keepStackSize();
 933     }
 934 :
 935 (
 936 { before(grammarAccess.getSenEnginesAccess().getGroup_2()); }
 937 (rule__SenEngines__Group_2__0)*
 938 { after(grammarAccess.getSenEnginesAccess().getGroup_2()); }
 939 )
 940
 941 ;
 942 finally {
 943         restoreStackSize(stackSize);
 944 }
 945
 946
 947 rule__SenEngines__Group__3
 948     @init {
 949                 int stackSize = keepStackSize();
 950     }
 951 :
 952         rule__SenEngines__Group__3__Impl
 953 ;
 954 finally {
 955         restoreStackSize(stackSize);
 956 }
 957
 958 rule__SenEngines__Group__3__Impl
 959     @init {
 960                 int stackSize = keepStackSize();
 961     }
 962 :
 963 (
 964 { before(grammarAccess.getSenEnginesAccess().getSemicolonKeyword_3()); }
 965
 966         ';'
 967
 968 { after(grammarAccess.getSenEnginesAccess().getSemicolonKeyword_3()); }
 969 )
 970
 971 ;
 972 finally {
 973         restoreStackSize(stackSize);
 974 }
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985 rule__SenEngines__Group_2__0
 986     @init {
 987                 int stackSize = keepStackSize();
 988     }
 989 :
 990         rule__SenEngines__Group_2__0__Impl
 991         rule__SenEngines__Group_2__1
 992 ;
 993 finally {
 994         restoreStackSize(stackSize);
 995 }
 996
 997 rule__SenEngines__Group_2__0__Impl
 998     @init {
 999                 int stackSize = keepStackSize();
1000     }
1001 :
1002 (
1003 { before(grammarAccess.getSenEnginesAccess().getCommaKeyword_2_0()); }
1004
1005         ','
1006
1007 { after(grammarAccess.getSenEnginesAccess().getCommaKeyword_2_0()); }
1008 )
1009
1010 ;
1011 finally {
1012         restoreStackSize(stackSize);
1013 }
1014
1015
1016 rule__SenEngines__Group_2__1
1017     @init {
1018                 int stackSize = keepStackSize();
1019     }
1020 :
1021         rule__SenEngines__Group_2__1__Impl
1022 ;
1023 finally {
1024         restoreStackSize(stackSize);
1025 }
1026
1027 rule__SenEngines__Group_2__1__Impl
1028     @init {
1029                 int stackSize = keepStackSize();
1030     }
1031 :
1032 (
1033 { before(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_2_1()); }
1034         ruleIpv4
1035 { after(grammarAccess.getSenEnginesAccess().getIpv4ParserRuleCall_2_1()); }
1036 )
1037
1038 ;
1039 finally {
1040         restoreStackSize(stackSize);
1041 }
1042
1043
1044
1045
1046
1047
1048 rule__Ipv4__Group__0
1049     @init {
1050                 int stackSize = keepStackSize();
1051     }
1052 :
1053         rule__Ipv4__Group__0__Impl
1054         rule__Ipv4__Group__1
1055 ;
1056 finally {
1057         restoreStackSize(stackSize);
1058 }
1059
1060 rule__Ipv4__Group__0__Impl
1061     @init {
1062                 int stackSize = keepStackSize();
1063     }
1064 :
1065 (
1066 { before(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_0()); }
1067         RULE_IPV4_SUB
1068 { after(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_0()); }
1069 )
1070
1071 ;
1072 finally {
1073         restoreStackSize(stackSize);
1074 }
1075
1076
1077 rule__Ipv4__Group__1
1078     @init {
1079                 int stackSize = keepStackSize();
1080     }
1081 :
1082         rule__Ipv4__Group__1__Impl
1083         rule__Ipv4__Group__2
1084 ;
1085 finally {
1086         restoreStackSize(stackSize);
1087 }
1088
1089 rule__Ipv4__Group__1__Impl
1090     @init {
1091                 int stackSize = keepStackSize();
1092     }
1093 :
1094 (
1095 { before(grammarAccess.getIpv4Access().getFullStopKeyword_1()); }
1096
1097         '.'
1098
1099 { after(grammarAccess.getIpv4Access().getFullStopKeyword_1()); }
1100 )
1101
1102 ;
1103 finally {
1104         restoreStackSize(stackSize);
1105 }
1106
1107
1108 rule__Ipv4__Group__2
1109     @init {
1110                 int stackSize = keepStackSize();
1111     }
1112 :
1113         rule__Ipv4__Group__2__Impl
1114         rule__Ipv4__Group__3
1115 ;
1116 finally {
1117         restoreStackSize(stackSize);
1118 }
1119
1120 rule__Ipv4__Group__2__Impl
1121     @init {
1122                 int stackSize = keepStackSize();
1123     }
1124 :
1125 (
1126 { before(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_2()); }
1127         RULE_IPV4_SUB
1128 { after(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_2()); }
1129 )
1130
1131 ;
1132 finally {
1133         restoreStackSize(stackSize);
1134 }
1135
1136
1137 rule__Ipv4__Group__3
1138     @init {
1139                 int stackSize = keepStackSize();
1140     }
1141 :
1142         rule__Ipv4__Group__3__Impl
1143         rule__Ipv4__Group__4
1144 ;
1145 finally {
1146         restoreStackSize(stackSize);
1147 }
1148
1149 rule__Ipv4__Group__3__Impl
1150     @init {
1151                 int stackSize = keepStackSize();
1152     }
1153 :
1154 (
1155 { before(grammarAccess.getIpv4Access().getFullStopKeyword_3()); }
1156
1157         '.'
1158
1159 { after(grammarAccess.getIpv4Access().getFullStopKeyword_3()); }
1160 )
1161
1162 ;
1163 finally {
1164         restoreStackSize(stackSize);
1165 }
1166
1167
1168 rule__Ipv4__Group__4
1169     @init {
1170                 int stackSize = keepStackSize();
1171     }
1172 :
1173         rule__Ipv4__Group__4__Impl
1174         rule__Ipv4__Group__5
1175 ;
1176 finally {
1177         restoreStackSize(stackSize);
1178 }
1179
1180 rule__Ipv4__Group__4__Impl
1181     @init {
1182                 int stackSize = keepStackSize();
1183     }
1184 :
1185 (
1186 { before(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_4()); }
1187         RULE_IPV4_SUB
1188 { after(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_4()); }
1189 )
1190
1191 ;
1192 finally {
1193         restoreStackSize(stackSize);
1194 }
1195
1196
1197 rule__Ipv4__Group__5
1198     @init {
1199                 int stackSize = keepStackSize();
1200     }
1201 :
1202         rule__Ipv4__Group__5__Impl
1203         rule__Ipv4__Group__6
1204 ;
1205 finally {
1206         restoreStackSize(stackSize);
1207 }
1208
1209 rule__Ipv4__Group__5__Impl
1210     @init {
1211                 int stackSize = keepStackSize();
1212     }
1213 :
1214 (
1215 { before(grammarAccess.getIpv4Access().getFullStopKeyword_5()); }
1216
1217         '.'
1218
1219 { after(grammarAccess.getIpv4Access().getFullStopKeyword_5()); }
1220 )
1221
1222 ;
1223 finally {
1224         restoreStackSize(stackSize);
1225 }
1226
1227
1228 rule__Ipv4__Group__6
1229     @init {
1230                 int stackSize = keepStackSize();
1231     }
1232 :
1233         rule__Ipv4__Group__6__Impl
1234 ;
1235 finally {
1236         restoreStackSize(stackSize);
1237 }
1238
1239 rule__Ipv4__Group__6__Impl
1240     @init {
1241                 int stackSize = keepStackSize();
1242     }
1243 :
1244 (
1245 { before(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_6()); }
1246         RULE_IPV4_SUB
1247 { after(grammarAccess.getIpv4Access().getIPV4_SUBTerminalRuleCall_6()); }
1248 )
1249
1250 ;
1251 finally {
1252         restoreStackSize(stackSize);
1253 }
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270 rule__User__Group__0
1271     @init {
1272                 int stackSize = keepStackSize();
1273     }
1274 :
1275         rule__User__Group__0__Impl
1276         rule__User__Group__1
1277 ;
1278 finally {
1279         restoreStackSize(stackSize);
1280 }
1281
1282 rule__User__Group__0__Impl
1283     @init {
1284                 int stackSize = keepStackSize();
1285     }
1286 :
1287 (
1288 { before(grammarAccess.getUserAccess().getCREATEKeyword_0()); }
1289
1290         'CREATE'
1291
1292 { after(grammarAccess.getUserAccess().getCREATEKeyword_0()); }
1293 )
1294
1295 ;
1296 finally {
1297         restoreStackSize(stackSize);
1298 }
1299
1300
1301 rule__User__Group__1
1302     @init {
1303                 int stackSize = keepStackSize();
1304     }
1305 :
1306         rule__User__Group__1__Impl
1307         rule__User__Group__2
1308 ;
1309 finally {
1310         restoreStackSize(stackSize);
1311 }
1312
1313 rule__User__Group__1__Impl
1314     @init {
1315                 int stackSize = keepStackSize();
1316     }
1317 :
1318 (
1319 { before(grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_1()); }
1320         RULE_STRING
1321 { after(grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_1()); }
1322 )
1323
1324 ;
1325 finally {
1326         restoreStackSize(stackSize);
1327 }
1328
1329
1330 rule__User__Group__2
1331     @init {
1332                 int stackSize = keepStackSize();
1333     }
1334 :
1335         rule__User__Group__2__Impl
1336         rule__User__Group__3
1337 ;
1338 finally {
1339         restoreStackSize(stackSize);
1340 }
1341
1342 rule__User__Group__2__Impl
1343     @init {
1344                 int stackSize = keepStackSize();
1345     }
1346 :
1347 (
1348 { before(grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_2()); }
1349         RULE_STRING
1350 { after(grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_2()); }
1351 )
1352
1353 ;
1354 finally {
1355         restoreStackSize(stackSize);
1356 }
1357
1358
1359 rule__User__Group__3
1360     @init {
1361                 int stackSize = keepStackSize();
1362     }
1363 :
1364         rule__User__Group__3__Impl
1365         rule__User__Group__4
1366 ;
1367 finally {
1368         restoreStackSize(stackSize);
1369 }
1370
1371 rule__User__Group__3__Impl
1372     @init {
1373                 int stackSize = keepStackSize();
1374     }
1375 :
1376 (
1377 { before(grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_3()); }
1378         RULE_STRING
1379 { after(grammarAccess.getUserAccess().getSTRINGTerminalRuleCall_3()); }
1380 )
1381
1382 ;
1383 finally {
1384         restoreStackSize(stackSize);
1385 }
1386
1387
1388 rule__User__Group__4
1389     @init {
1390                 int stackSize = keepStackSize();
1391     }
1392 :
1393         rule__User__Group__4__Impl
1394 ;
1395 finally {
1396         restoreStackSize(stackSize);
1397 }
1398
1399 rule__User__Group__4__Impl
1400     @init {
1401                 int stackSize = keepStackSize();
1402     }
1403 :
1404 (
1405 { before(grammarAccess.getUserAccess().getSemicolonKeyword_4()); }
1406
1407         ';'
1408
1409 { after(grammarAccess.getUserAccess().getSemicolonKeyword_4()); }
1410 )
1411
1412 ;
1413 finally {
1414         restoreStackSize(stackSize);
1415 }
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428 rule__Node__Group__0
1429     @init {
1430                 int stackSize = keepStackSize();
1431     }
1432 :
1433         rule__Node__Group__0__Impl
1434         rule__Node__Group__1
1435 ;
1436 finally {
1437         restoreStackSize(stackSize);
1438 }
1439
1440 rule__Node__Group__0__Impl
1441     @init {
1442                 int stackSize = keepStackSize();
1443     }
1444 :
1445 (
1446 { before(grammarAccess.getNodeAccess().getNewObjParserRuleCall_0()); }
1447         ruleNewObj
1448 { after(grammarAccess.getNodeAccess().getNewObjParserRuleCall_0()); }
1449 )
1450
1451 ;
1452 finally {
1453         restoreStackSize(stackSize);
1454 }
1455
1456
1457 rule__Node__Group__1
1458     @init {
1459                 int stackSize = keepStackSize();
1460     }
1461 :
1462         rule__Node__Group__1__Impl
1463         rule__Node__Group__2
1464 ;
1465 finally {
1466         restoreStackSize(stackSize);
1467 }
1468
1469 rule__Node__Group__1__Impl
1470     @init {
1471                 int stackSize = keepStackSize();
1472     }
1473 :
1474 (
1475 { before(grammarAccess.getNodeAccess().getNodeKeyword_1()); }
1476
1477         'Node'
1478
1479 { after(grammarAccess.getNodeAccess().getNodeKeyword_1()); }
1480 )
1481
1482 ;
1483 finally {
1484         restoreStackSize(stackSize);
1485 }
1486
1487
1488 rule__Node__Group__2
1489     @init {
1490                 int stackSize = keepStackSize();
1491     }
1492 :
1493         rule__Node__Group__2__Impl
1494         rule__Node__Group__3
1495 ;
1496 finally {
1497         restoreStackSize(stackSize);
1498 }
1499
1500 rule__Node__Group__2__Impl
1501     @init {
1502                 int stackSize = keepStackSize();
1503     }
1504 :
1505 (
1506 { before(grammarAccess.getNodeAccess().getNameAssignment_2()); }
1507 (rule__Node__NameAssignment_2)
1508 { after(grammarAccess.getNodeAccess().getNameAssignment_2()); }
1509 )
1510
1511 ;
1512 finally {
1513         restoreStackSize(stackSize);
1514 }
1515
1516
1517 rule__Node__Group__3
1518     @init {
1519                 int stackSize = keepStackSize();
1520     }
1521 :
1522         rule__Node__Group__3__Impl
1523         rule__Node__Group__4
1524 ;
1525 finally {
1526         restoreStackSize(stackSize);
1527 }
1528
1529 rule__Node__Group__3__Impl
1530     @init {
1531                 int stackSize = keepStackSize();
1532     }
1533 :
1534 (
1535 { before(grammarAccess.getNodeAccess().getGroup_3()); }
1536 (rule__Node__Group_3__0)
1537 { after(grammarAccess.getNodeAccess().getGroup_3()); }
1538 )
1539
1540 ;
1541 finally {
1542         restoreStackSize(stackSize);
1543 }
1544
1545
1546 rule__Node__Group__4
1547     @init {
1548                 int stackSize = keepStackSize();
1549     }
1550 :
1551         rule__Node__Group__4__Impl
1552         rule__Node__Group__5
1553 ;
1554 finally {
1555         restoreStackSize(stackSize);
1556 }
1557
1558 rule__Node__Group__4__Impl
1559     @init {
1560                 int stackSize = keepStackSize();
1561     }
1562 :
1563 (
1564 { before(grammarAccess.getNodeAccess().getGroup_4()); }
1565 (rule__Node__Group_4__0)?
1566 { after(grammarAccess.getNodeAccess().getGroup_4()); }
1567 )
1568
1569 ;
1570 finally {
1571         restoreStackSize(stackSize);
1572 }
1573
1574
1575 rule__Node__Group__5
1576     @init {
1577                 int stackSize = keepStackSize();
1578     }
1579 :
1580         rule__Node__Group__5__Impl
1581         rule__Node__Group__6
1582 ;
1583 finally {
1584         restoreStackSize(stackSize);
1585 }
1586
1587 rule__Node__Group__5__Impl
1588     @init {
1589                 int stackSize = keepStackSize();
1590     }
1591 :
1592 (
1593 { before(grammarAccess.getNodeAccess().getPropertyParserRuleCall_5()); }
1594 (       ruleProperty)?
1595 { after(grammarAccess.getNodeAccess().getPropertyParserRuleCall_5()); }
1596 )
1597
1598 ;
1599 finally {
1600         restoreStackSize(stackSize);
1601 }
1602
1603
1604 rule__Node__Group__6
1605     @init {
1606                 int stackSize = keepStackSize();
1607     }
1608 :
1609         rule__Node__Group__6__Impl
1610 ;
1611 finally {
1612         restoreStackSize(stackSize);
1613 }
1614
1615 rule__Node__Group__6__Impl
1616     @init {
1617                 int stackSize = keepStackSize();
1618     }
1619 :
1620 (
1621 { before(grammarAccess.getNodeAccess().getSemicolonKeyword_6()); }
1622
1623         ';'
1624
1625 { after(grammarAccess.getNodeAccess().getSemicolonKeyword_6()); }
1626 )
1627
1628 ;
1629 finally {
1630         restoreStackSize(stackSize);
1631 }
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648 rule__Node__Group_3__0
1649     @init {
1650                 int stackSize = keepStackSize();
1651     }
1652 :
1653         rule__Node__Group_3__0__Impl
1654         rule__Node__Group_3__1
1655 ;
1656 finally {
1657         restoreStackSize(stackSize);
1658 }
1659
1660 rule__Node__Group_3__0__Impl
1661     @init {
1662                 int stackSize = keepStackSize();
1663     }
1664 :
1665 (
1666 { before(grammarAccess.getNodeAccess().getTypeKeyword_3_0()); }
1667
1668         'Type'
1669
1670 { after(grammarAccess.getNodeAccess().getTypeKeyword_3_0()); }
1671 )
1672
1673 ;
1674 finally {
1675         restoreStackSize(stackSize);
1676 }
1677
1678
1679 rule__Node__Group_3__1
1680     @init {
1681                 int stackSize = keepStackSize();
1682     }
1683 :
1684         rule__Node__Group_3__1__Impl
1685 ;
1686 finally {
1687         restoreStackSize(stackSize);
1688 }
1689
1690 rule__Node__Group_3__1__Impl
1691     @init {
1692                 int stackSize = keepStackSize();
1693     }
1694 :
1695 (
1696 { before(grammarAccess.getNodeAccess().getNemoIdTerminalRuleCall_3_1()); }
1697         RULE_NEMOID
1698 { after(grammarAccess.getNodeAccess().getNemoIdTerminalRuleCall_3_1()); }
1699 )
1700
1701 ;
1702 finally {
1703         restoreStackSize(stackSize);
1704 }
1705
1706
1707
1708
1709
1710
1711 rule__Node__Group_4__0
1712     @init {
1713                 int stackSize = keepStackSize();
1714     }
1715 :
1716         rule__Node__Group_4__0__Impl
1717         rule__Node__Group_4__1
1718 ;
1719 finally {
1720         restoreStackSize(stackSize);
1721 }
1722
1723 rule__Node__Group_4__0__Impl
1724     @init {
1725                 int stackSize = keepStackSize();
1726     }
1727 :
1728 (
1729 { before(grammarAccess.getNodeAccess().getContainKeyword_4_0()); }
1730
1731         'Contain'
1732
1733 { after(grammarAccess.getNodeAccess().getContainKeyword_4_0()); }
1734 )
1735
1736 ;
1737 finally {
1738         restoreStackSize(stackSize);
1739 }
1740
1741
1742 rule__Node__Group_4__1
1743     @init {
1744                 int stackSize = keepStackSize();
1745     }
1746 :
1747         rule__Node__Group_4__1__Impl
1748         rule__Node__Group_4__2
1749 ;
1750 finally {
1751         restoreStackSize(stackSize);
1752 }
1753
1754 rule__Node__Group_4__1__Impl
1755     @init {
1756                 int stackSize = keepStackSize();
1757     }
1758 :
1759 (
1760 { before(grammarAccess.getNodeAccess().getNodesAssignment_4_1()); }
1761 (rule__Node__NodesAssignment_4_1)
1762 { after(grammarAccess.getNodeAccess().getNodesAssignment_4_1()); }
1763 )
1764
1765 ;
1766 finally {
1767         restoreStackSize(stackSize);
1768 }
1769
1770
1771 rule__Node__Group_4__2
1772     @init {
1773                 int stackSize = keepStackSize();
1774     }
1775 :
1776         rule__Node__Group_4__2__Impl
1777 ;
1778 finally {
1779         restoreStackSize(stackSize);
1780 }
1781
1782 rule__Node__Group_4__2__Impl
1783     @init {
1784                 int stackSize = keepStackSize();
1785     }
1786 :
1787 (
1788 { before(grammarAccess.getNodeAccess().getGroup_4_2()); }
1789 (rule__Node__Group_4_2__0)*
1790 { after(grammarAccess.getNodeAccess().getGroup_4_2()); }
1791 )
1792
1793 ;
1794 finally {
1795         restoreStackSize(stackSize);
1796 }
1797
1798
1799
1800
1801
1802
1803
1804
1805 rule__Node__Group_4_2__0
1806     @init {
1807                 int stackSize = keepStackSize();
1808     }
1809 :
1810         rule__Node__Group_4_2__0__Impl
1811         rule__Node__Group_4_2__1
1812 ;
1813 finally {
1814         restoreStackSize(stackSize);
1815 }
1816
1817 rule__Node__Group_4_2__0__Impl
1818     @init {
1819                 int stackSize = keepStackSize();
1820     }
1821 :
1822 (
1823 { before(grammarAccess.getNodeAccess().getCommaKeyword_4_2_0()); }
1824
1825         ','
1826
1827 { after(grammarAccess.getNodeAccess().getCommaKeyword_4_2_0()); }
1828 )
1829
1830 ;
1831 finally {
1832         restoreStackSize(stackSize);
1833 }
1834
1835
1836 rule__Node__Group_4_2__1
1837     @init {
1838                 int stackSize = keepStackSize();
1839     }
1840 :
1841         rule__Node__Group_4_2__1__Impl
1842 ;
1843 finally {
1844         restoreStackSize(stackSize);
1845 }
1846
1847 rule__Node__Group_4_2__1__Impl
1848     @init {
1849                 int stackSize = keepStackSize();
1850     }
1851 :
1852 (
1853 { before(grammarAccess.getNodeAccess().getNodesAssignment_4_2_1()); }
1854 (rule__Node__NodesAssignment_4_2_1)
1855 { after(grammarAccess.getNodeAccess().getNodesAssignment_4_2_1()); }
1856 )
1857
1858 ;
1859 finally {
1860         restoreStackSize(stackSize);
1861 }
1862
1863
1864
1865
1866
1867
1868
1869 rule__NodeOperating__Group__0
1870     @init {
1871                 int stackSize = keepStackSize();
1872     }
1873 :
1874         rule__NodeOperating__Group__0__Impl
1875         rule__NodeOperating__Group__1
1876 ;
1877 finally {
1878         restoreStackSize(stackSize);
1879 }
1880
1881 rule__NodeOperating__Group__0__Impl
1882     @init {
1883                 int stackSize = keepStackSize();
1884     }
1885 :
1886 (
1887 { before(grammarAccess.getNodeOperatingAccess().getAlternatives_0()); }
1888 (rule__NodeOperating__Alternatives_0)
1889 { after(grammarAccess.getNodeOperatingAccess().getAlternatives_0()); }
1890 )
1891
1892 ;
1893 finally {
1894         restoreStackSize(stackSize);
1895 }
1896
1897
1898 rule__NodeOperating__Group__1
1899     @init {
1900                 int stackSize = keepStackSize();
1901     }
1902 :
1903         rule__NodeOperating__Group__1__Impl
1904         rule__NodeOperating__Group__2
1905 ;
1906 finally {
1907         restoreStackSize(stackSize);
1908 }
1909
1910 rule__NodeOperating__Group__1__Impl
1911     @init {
1912                 int stackSize = keepStackSize();
1913     }
1914 :
1915 (
1916 { before(grammarAccess.getNodeOperatingAccess().getNodeKeyword_1()); }
1917
1918         'Node'
1919
1920 { after(grammarAccess.getNodeOperatingAccess().getNodeKeyword_1()); }
1921 )
1922
1923 ;
1924 finally {
1925         restoreStackSize(stackSize);
1926 }
1927
1928
1929 rule__NodeOperating__Group__2
1930     @init {
1931                 int stackSize = keepStackSize();
1932     }
1933 :
1934         rule__NodeOperating__Group__2__Impl
1935         rule__NodeOperating__Group__3
1936 ;
1937 finally {
1938         restoreStackSize(stackSize);
1939 }
1940
1941 rule__NodeOperating__Group__2__Impl
1942     @init {
1943                 int stackSize = keepStackSize();
1944     }
1945 :
1946 (
1947 { before(grammarAccess.getNodeOperatingAccess().getNodenameAssignment_2()); }
1948 (rule__NodeOperating__NodenameAssignment_2)
1949 { after(grammarAccess.getNodeOperatingAccess().getNodenameAssignment_2()); }
1950 )
1951
1952 ;
1953 finally {
1954         restoreStackSize(stackSize);
1955 }
1956
1957
1958 rule__NodeOperating__Group__3
1959     @init {
1960                 int stackSize = keepStackSize();
1961     }
1962 :
1963         rule__NodeOperating__Group__3__Impl
1964         rule__NodeOperating__Group__4
1965 ;
1966 finally {
1967         restoreStackSize(stackSize);
1968 }
1969
1970 rule__NodeOperating__Group__3__Impl
1971     @init {
1972                 int stackSize = keepStackSize();
1973     }
1974 :
1975 (
1976 { before(grammarAccess.getNodeOperatingAccess().getGroup_3()); }
1977 (rule__NodeOperating__Group_3__0)?
1978 { after(grammarAccess.getNodeOperatingAccess().getGroup_3()); }
1979 )
1980
1981 ;
1982 finally {
1983         restoreStackSize(stackSize);
1984 }
1985
1986
1987 rule__NodeOperating__Group__4
1988     @init {
1989                 int stackSize = keepStackSize();
1990     }
1991 :
1992         rule__NodeOperating__Group__4__Impl
1993         rule__NodeOperating__Group__5
1994 ;
1995 finally {
1996         restoreStackSize(stackSize);
1997 }
1998
1999 rule__NodeOperating__Group__4__Impl
2000     @init {
2001                 int stackSize = keepStackSize();
2002     }
2003 :
2004 (
2005 { before(grammarAccess.getNodeOperatingAccess().getGroup_4()); }
2006 (rule__NodeOperating__Group_4__0)?
2007 { after(grammarAccess.getNodeOperatingAccess().getGroup_4()); }
2008 )
2009
2010 ;
2011 finally {
2012         restoreStackSize(stackSize);
2013 }
2014
2015
2016 rule__NodeOperating__Group__5
2017     @init {
2018                 int stackSize = keepStackSize();
2019     }
2020 :
2021         rule__NodeOperating__Group__5__Impl
2022         rule__NodeOperating__Group__6
2023 ;
2024 finally {
2025         restoreStackSize(stackSize);
2026 }
2027
2028 rule__NodeOperating__Group__5__Impl
2029     @init {
2030                 int stackSize = keepStackSize();
2031     }
2032 :
2033 (
2034 { before(grammarAccess.getNodeOperatingAccess().getPropertyParserRuleCall_5()); }
2035 (       ruleProperty)?
2036 { after(grammarAccess.getNodeOperatingAccess().getPropertyParserRuleCall_5()); }
2037 )
2038
2039 ;
2040 finally {
2041         restoreStackSize(stackSize);
2042 }
2043
2044
2045 rule__NodeOperating__Group__6
2046     @init {
2047                 int stackSize = keepStackSize();
2048     }
2049 :
2050         rule__NodeOperating__Group__6__Impl
2051 ;
2052 finally {
2053         restoreStackSize(stackSize);
2054 }
2055
2056 rule__NodeOperating__Group__6__Impl
2057     @init {
2058                 int stackSize = keepStackSize();
2059     }
2060 :
2061 (
2062 { before(grammarAccess.getNodeOperatingAccess().getSemicolonKeyword_6()); }
2063
2064         ';'
2065
2066 { after(grammarAccess.getNodeOperatingAccess().getSemicolonKeyword_6()); }
2067 )
2068
2069 ;
2070 finally {
2071         restoreStackSize(stackSize);
2072 }
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089 rule__NodeOperating__Group_3__0
2090     @init {
2091                 int stackSize = keepStackSize();
2092     }
2093 :
2094         rule__NodeOperating__Group_3__0__Impl
2095         rule__NodeOperating__Group_3__1
2096 ;
2097 finally {
2098         restoreStackSize(stackSize);
2099 }
2100
2101 rule__NodeOperating__Group_3__0__Impl
2102     @init {
2103                 int stackSize = keepStackSize();
2104     }
2105 :
2106 (
2107 { before(grammarAccess.getNodeOperatingAccess().getTypeKeyword_3_0()); }
2108
2109         'Type'
2110
2111 { after(grammarAccess.getNodeOperatingAccess().getTypeKeyword_3_0()); }
2112 )
2113
2114 ;
2115 finally {
2116         restoreStackSize(stackSize);
2117 }
2118
2119
2120 rule__NodeOperating__Group_3__1
2121     @init {
2122                 int stackSize = keepStackSize();
2123     }
2124 :
2125         rule__NodeOperating__Group_3__1__Impl
2126 ;
2127 finally {
2128         restoreStackSize(stackSize);
2129 }
2130
2131 rule__NodeOperating__Group_3__1__Impl
2132     @init {
2133                 int stackSize = keepStackSize();
2134     }
2135 :
2136 (
2137 { before(grammarAccess.getNodeOperatingAccess().getNemoIdTerminalRuleCall_3_1()); }
2138         RULE_NEMOID
2139 { after(grammarAccess.getNodeOperatingAccess().getNemoIdTerminalRuleCall_3_1()); }
2140 )
2141
2142 ;
2143 finally {
2144         restoreStackSize(stackSize);
2145 }
2146
2147
2148
2149
2150
2151
2152 rule__NodeOperating__Group_4__0
2153     @init {
2154                 int stackSize = keepStackSize();
2155     }
2156 :
2157         rule__NodeOperating__Group_4__0__Impl
2158         rule__NodeOperating__Group_4__1
2159 ;
2160 finally {
2161         restoreStackSize(stackSize);
2162 }
2163
2164 rule__NodeOperating__Group_4__0__Impl
2165     @init {
2166                 int stackSize = keepStackSize();
2167     }
2168 :
2169 (
2170 { before(grammarAccess.getNodeOperatingAccess().getContainKeyword_4_0()); }
2171
2172         'Contain'
2173
2174 { after(grammarAccess.getNodeOperatingAccess().getContainKeyword_4_0()); }
2175 )
2176
2177 ;
2178 finally {
2179         restoreStackSize(stackSize);
2180 }
2181
2182
2183 rule__NodeOperating__Group_4__1
2184     @init {
2185                 int stackSize = keepStackSize();
2186     }
2187 :
2188         rule__NodeOperating__Group_4__1__Impl
2189         rule__NodeOperating__Group_4__2
2190 ;
2191 finally {
2192         restoreStackSize(stackSize);
2193 }
2194
2195 rule__NodeOperating__Group_4__1__Impl
2196     @init {
2197                 int stackSize = keepStackSize();
2198     }
2199 :
2200 (
2201 { before(grammarAccess.getNodeOperatingAccess().getNodesAssignment_4_1()); }
2202 (rule__NodeOperating__NodesAssignment_4_1)
2203 { after(grammarAccess.getNodeOperatingAccess().getNodesAssignment_4_1()); }
2204 )
2205
2206 ;
2207 finally {
2208         restoreStackSize(stackSize);
2209 }
2210
2211
2212 rule__NodeOperating__Group_4__2
2213     @init {
2214                 int stackSize = keepStackSize();
2215     }
2216 :
2217         rule__NodeOperating__Group_4__2__Impl
2218 ;
2219 finally {
2220         restoreStackSize(stackSize);
2221 }
2222
2223 rule__NodeOperating__Group_4__2__Impl
2224     @init {
2225                 int stackSize = keepStackSize();
2226     }
2227 :
2228 (
2229 { before(grammarAccess.getNodeOperatingAccess().getGroup_4_2()); }
2230 (rule__NodeOperating__Group_4_2__0)*
2231 { after(grammarAccess.getNodeOperatingAccess().getGroup_4_2()); }
2232 )
2233
2234 ;
2235 finally {
2236         restoreStackSize(stackSize);
2237 }
2238
2239
2240
2241
2242
2243
2244
2245
2246 rule__NodeOperating__Group_4_2__0
2247     @init {
2248                 int stackSize = keepStackSize();
2249     }
2250 :
2251         rule__NodeOperating__Group_4_2__0__Impl
2252         rule__NodeOperating__Group_4_2__1
2253 ;
2254 finally {
2255         restoreStackSize(stackSize);
2256 }
2257
2258 rule__NodeOperating__Group_4_2__0__Impl
2259     @init {
2260                 int stackSize = keepStackSize();
2261     }
2262 :
2263 (
2264 { before(grammarAccess.getNodeOperatingAccess().getCommaKeyword_4_2_0()); }
2265
2266         ','
2267
2268 { after(grammarAccess.getNodeOperatingAccess().getCommaKeyword_4_2_0()); }
2269 )
2270
2271 ;
2272 finally {
2273         restoreStackSize(stackSize);
2274 }
2275
2276
2277 rule__NodeOperating__Group_4_2__1
2278     @init {
2279                 int stackSize = keepStackSize();
2280     }
2281 :
2282         rule__NodeOperating__Group_4_2__1__Impl
2283 ;
2284 finally {
2285         restoreStackSize(stackSize);
2286 }
2287
2288 rule__NodeOperating__Group_4_2__1__Impl
2289     @init {
2290                 int stackSize = keepStackSize();
2291     }
2292 :
2293 (
2294 { before(grammarAccess.getNodeOperatingAccess().getNodesAssignment_4_2_1()); }
2295 (rule__NodeOperating__NodesAssignment_4_2_1)
2296 { after(grammarAccess.getNodeOperatingAccess().getNodesAssignment_4_2_1()); }
2297 )
2298
2299 ;
2300 finally {
2301         restoreStackSize(stackSize);
2302 }
2303
2304
2305
2306
2307
2308
2309 rule__Connection__Group__0
2310     @init {
2311                 int stackSize = keepStackSize();
2312     }
2313 :
2314         rule__Connection__Group__0__Impl
2315         rule__Connection__Group__1
2316 ;
2317 finally {
2318         restoreStackSize(stackSize);
2319 }
2320
2321 rule__Connection__Group__0__Impl
2322     @init {
2323                 int stackSize = keepStackSize();
2324     }
2325 :
2326 (
2327 { before(grammarAccess.getConnectionAccess().getCREATEKeyword_0()); }
2328
2329         'CREATE'
2330
2331 { after(grammarAccess.getConnectionAccess().getCREATEKeyword_0()); }
2332 )
2333
2334 ;
2335 finally {
2336         restoreStackSize(stackSize);
2337 }
2338
2339
2340 rule__Connection__Group__1
2341     @init {
2342                 int stackSize = keepStackSize();
2343     }
2344 :
2345         rule__Connection__Group__1__Impl
2346         rule__Connection__Group__2
2347 ;
2348 finally {
2349         restoreStackSize(stackSize);
2350 }
2351
2352 rule__Connection__Group__1__Impl
2353     @init {
2354                 int stackSize = keepStackSize();
2355     }
2356 :
2357 (
2358 { before(grammarAccess.getConnectionAccess().getConnectionKeyword_1()); }
2359
2360         'Connection'
2361
2362 { after(grammarAccess.getConnectionAccess().getConnectionKeyword_1()); }
2363 )
2364
2365 ;
2366 finally {
2367         restoreStackSize(stackSize);
2368 }
2369
2370
2371 rule__Connection__Group__2
2372     @init {
2373                 int stackSize = keepStackSize();
2374     }
2375 :
2376         rule__Connection__Group__2__Impl
2377         rule__Connection__Group__3
2378 ;
2379 finally {
2380         restoreStackSize(stackSize);
2381 }
2382
2383 rule__Connection__Group__2__Impl
2384     @init {
2385                 int stackSize = keepStackSize();
2386     }
2387 :
2388 (
2389 { before(grammarAccess.getConnectionAccess().getNameAssignment_2()); }
2390 (rule__Connection__NameAssignment_2)
2391 { after(grammarAccess.getConnectionAccess().getNameAssignment_2()); }
2392 )
2393
2394 ;
2395 finally {
2396         restoreStackSize(stackSize);
2397 }
2398
2399
2400 rule__Connection__Group__3
2401     @init {
2402                 int stackSize = keepStackSize();
2403     }
2404 :
2405         rule__Connection__Group__3__Impl
2406         rule__Connection__Group__4
2407 ;
2408 finally {
2409         restoreStackSize(stackSize);
2410 }
2411
2412 rule__Connection__Group__3__Impl
2413     @init {
2414                 int stackSize = keepStackSize();
2415     }
2416 :
2417 (
2418 { before(grammarAccess.getConnectionAccess().getTypeKeyword_3()); }
2419
2420         'Type'
2421
2422 { after(grammarAccess.getConnectionAccess().getTypeKeyword_3()); }
2423 )
2424
2425 ;
2426 finally {
2427         restoreStackSize(stackSize);
2428 }
2429
2430
2431 rule__Connection__Group__4
2432     @init {
2433                 int stackSize = keepStackSize();
2434     }
2435 :
2436         rule__Connection__Group__4__Impl
2437         rule__Connection__Group__5
2438 ;
2439 finally {
2440         restoreStackSize(stackSize);
2441 }
2442
2443 rule__Connection__Group__4__Impl
2444     @init {
2445                 int stackSize = keepStackSize();
2446     }
2447 :
2448 (
2449 { before(grammarAccess.getConnectionAccess().getNemoIdTerminalRuleCall_4()); }
2450         RULE_NEMOID
2451 { after(grammarAccess.getConnectionAccess().getNemoIdTerminalRuleCall_4()); }
2452 )
2453
2454 ;
2455 finally {
2456         restoreStackSize(stackSize);
2457 }
2458
2459
2460 rule__Connection__Group__5
2461     @init {
2462                 int stackSize = keepStackSize();
2463     }
2464 :
2465         rule__Connection__Group__5__Impl
2466         rule__Connection__Group__6
2467 ;
2468 finally {
2469         restoreStackSize(stackSize);
2470 }
2471
2472 rule__Connection__Group__5__Impl
2473     @init {
2474                 int stackSize = keepStackSize();
2475     }
2476 :
2477 (
2478 { before(grammarAccess.getConnectionAccess().getGroup_5()); }
2479 (rule__Connection__Group_5__0)
2480 { after(grammarAccess.getConnectionAccess().getGroup_5()); }
2481 )
2482
2483 ;
2484 finally {
2485         restoreStackSize(stackSize);
2486 }
2487
2488
2489 rule__Connection__Group__6
2490     @init {
2491                 int stackSize = keepStackSize();
2492     }
2493 :
2494         rule__Connection__Group__6__Impl
2495         rule__Connection__Group__7
2496 ;
2497 finally {
2498         restoreStackSize(stackSize);
2499 }
2500
2501 rule__Connection__Group__6__Impl
2502     @init {
2503                 int stackSize = keepStackSize();
2504     }
2505 :
2506 (
2507 { before(grammarAccess.getConnectionAccess().getPropertyParserRuleCall_6()); }
2508 (       ruleProperty)?
2509 { after(grammarAccess.getConnectionAccess().getPropertyParserRuleCall_6()); }
2510 )
2511
2512 ;
2513 finally {
2514         restoreStackSize(stackSize);
2515 }
2516
2517
2518 rule__Connection__Group__7
2519     @init {
2520                 int stackSize = keepStackSize();
2521     }
2522 :
2523         rule__Connection__Group__7__Impl
2524 ;
2525 finally {
2526         restoreStackSize(stackSize);
2527 }
2528
2529 rule__Connection__Group__7__Impl
2530     @init {
2531                 int stackSize = keepStackSize();
2532     }
2533 :
2534 (
2535 { before(grammarAccess.getConnectionAccess().getSemicolonKeyword_7()); }
2536
2537         ';'
2538
2539 { after(grammarAccess.getConnectionAccess().getSemicolonKeyword_7()); }
2540 )
2541
2542 ;
2543 finally {
2544         restoreStackSize(stackSize);
2545 }
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564 rule__Connection__Group_5__0
2565     @init {
2566                 int stackSize = keepStackSize();
2567     }
2568 :
2569         rule__Connection__Group_5__0__Impl
2570         rule__Connection__Group_5__1
2571 ;
2572 finally {
2573         restoreStackSize(stackSize);
2574 }
2575
2576 rule__Connection__Group_5__0__Impl
2577     @init {
2578                 int stackSize = keepStackSize();
2579     }
2580 :
2581 (
2582 { before(grammarAccess.getConnectionAccess().getEndnodesKeyword_5_0()); }
2583
2584         'Endnodes'
2585
2586 { after(grammarAccess.getConnectionAccess().getEndnodesKeyword_5_0()); }
2587 )
2588
2589 ;
2590 finally {
2591         restoreStackSize(stackSize);
2592 }
2593
2594
2595 rule__Connection__Group_5__1
2596     @init {
2597                 int stackSize = keepStackSize();
2598     }
2599 :
2600         rule__Connection__Group_5__1__Impl
2601         rule__Connection__Group_5__2
2602 ;
2603 finally {
2604         restoreStackSize(stackSize);
2605 }
2606
2607 rule__Connection__Group_5__1__Impl
2608     @init {
2609                 int stackSize = keepStackSize();
2610     }
2611 :
2612 (
2613 { before(grammarAccess.getConnectionAccess().getEndnodeAssignment_5_1()); }
2614 (rule__Connection__EndnodeAssignment_5_1)
2615 { after(grammarAccess.getConnectionAccess().getEndnodeAssignment_5_1()); }
2616 )
2617
2618 ;
2619 finally {
2620         restoreStackSize(stackSize);
2621 }
2622
2623
2624 rule__Connection__Group_5__2
2625     @init {
2626                 int stackSize = keepStackSize();
2627     }
2628 :
2629         rule__Connection__Group_5__2__Impl
2630 ;
2631 finally {
2632         restoreStackSize(stackSize);
2633 }
2634
2635 rule__Connection__Group_5__2__Impl
2636     @init {
2637                 int stackSize = keepStackSize();
2638     }
2639 :
2640 (
2641 { before(grammarAccess.getConnectionAccess().getGroup_5_2()); }
2642 (rule__Connection__Group_5_2__0)*
2643 { after(grammarAccess.getConnectionAccess().getGroup_5_2()); }
2644 )
2645
2646 ;
2647 finally {
2648         restoreStackSize(stackSize);
2649 }
2650
2651
2652
2653
2654
2655
2656
2657
2658 rule__Connection__Group_5_2__0
2659     @init {
2660                 int stackSize = keepStackSize();
2661     }
2662 :
2663         rule__Connection__Group_5_2__0__Impl
2664         rule__Connection__Group_5_2__1
2665 ;
2666 finally {
2667         restoreStackSize(stackSize);
2668 }
2669
2670 rule__Connection__Group_5_2__0__Impl
2671     @init {
2672                 int stackSize = keepStackSize();
2673     }
2674 :
2675 (
2676 { before(grammarAccess.getConnectionAccess().getCommaKeyword_5_2_0()); }
2677
2678         ','
2679
2680 { after(grammarAccess.getConnectionAccess().getCommaKeyword_5_2_0()); }
2681 )
2682
2683 ;
2684 finally {
2685         restoreStackSize(stackSize);
2686 }
2687
2688
2689 rule__Connection__Group_5_2__1
2690     @init {
2691                 int stackSize = keepStackSize();
2692     }
2693 :
2694         rule__Connection__Group_5_2__1__Impl
2695 ;
2696 finally {
2697         restoreStackSize(stackSize);
2698 }
2699
2700 rule__Connection__Group_5_2__1__Impl
2701     @init {
2702                 int stackSize = keepStackSize();
2703     }
2704 :
2705 (
2706 { before(grammarAccess.getConnectionAccess().getEndnodeAssignment_5_2_1()); }
2707 (rule__Connection__EndnodeAssignment_5_2_1)
2708 { after(grammarAccess.getConnectionAccess().getEndnodeAssignment_5_2_1()); }
2709 )
2710
2711 ;
2712 finally {
2713         restoreStackSize(stackSize);
2714 }
2715
2716
2717
2718
2719
2720
2721 rule__ConnectionUpdate__Group__0
2722     @init {
2723                 int stackSize = keepStackSize();
2724     }
2725 :
2726         rule__ConnectionUpdate__Group__0__Impl
2727         rule__ConnectionUpdate__Group__1
2728 ;
2729 finally {
2730         restoreStackSize(stackSize);
2731 }
2732
2733 rule__ConnectionUpdate__Group__0__Impl
2734     @init {
2735                 int stackSize = keepStackSize();
2736     }
2737 :
2738 (
2739 { before(grammarAccess.getConnectionUpdateAccess().getAlternatives_0()); }
2740 (rule__ConnectionUpdate__Alternatives_0)
2741 { after(grammarAccess.getConnectionUpdateAccess().getAlternatives_0()); }
2742 )
2743
2744 ;
2745 finally {
2746         restoreStackSize(stackSize);
2747 }
2748
2749
2750 rule__ConnectionUpdate__Group__1
2751     @init {
2752                 int stackSize = keepStackSize();
2753     }
2754 :
2755         rule__ConnectionUpdate__Group__1__Impl
2756         rule__ConnectionUpdate__Group__2
2757 ;
2758 finally {
2759         restoreStackSize(stackSize);
2760 }
2761
2762 rule__ConnectionUpdate__Group__1__Impl
2763     @init {
2764                 int stackSize = keepStackSize();
2765     }
2766 :
2767 (
2768 { before(grammarAccess.getConnectionUpdateAccess().getConnectionKeyword_1()); }
2769
2770         'Connection'
2771
2772 { after(grammarAccess.getConnectionUpdateAccess().getConnectionKeyword_1()); }
2773 )
2774
2775 ;
2776 finally {
2777         restoreStackSize(stackSize);
2778 }
2779
2780
2781 rule__ConnectionUpdate__Group__2
2782     @init {
2783                 int stackSize = keepStackSize();
2784     }
2785 :
2786         rule__ConnectionUpdate__Group__2__Impl
2787         rule__ConnectionUpdate__Group__3
2788 ;
2789 finally {
2790         restoreStackSize(stackSize);
2791 }
2792
2793 rule__ConnectionUpdate__Group__2__Impl
2794     @init {
2795                 int stackSize = keepStackSize();
2796     }
2797 :
2798 (
2799 { before(grammarAccess.getConnectionUpdateAccess().getConnectionnameAssignment_2()); }
2800 (rule__ConnectionUpdate__ConnectionnameAssignment_2)
2801 { after(grammarAccess.getConnectionUpdateAccess().getConnectionnameAssignment_2()); }
2802 )
2803
2804 ;
2805 finally {
2806         restoreStackSize(stackSize);
2807 }
2808
2809
2810 rule__ConnectionUpdate__Group__3
2811     @init {
2812                 int stackSize = keepStackSize();
2813     }
2814 :
2815         rule__ConnectionUpdate__Group__3__Impl
2816         rule__ConnectionUpdate__Group__4
2817 ;
2818 finally {
2819         restoreStackSize(stackSize);
2820 }
2821
2822 rule__ConnectionUpdate__Group__3__Impl
2823     @init {
2824                 int stackSize = keepStackSize();
2825     }
2826 :
2827 (
2828 { before(grammarAccess.getConnectionUpdateAccess().getGroup_3()); }
2829 (rule__ConnectionUpdate__Group_3__0)?
2830 { after(grammarAccess.getConnectionUpdateAccess().getGroup_3()); }
2831 )
2832
2833 ;
2834 finally {
2835         restoreStackSize(stackSize);
2836 }
2837
2838
2839 rule__ConnectionUpdate__Group__4
2840     @init {
2841                 int stackSize = keepStackSize();
2842     }
2843 :
2844         rule__ConnectionUpdate__Group__4__Impl
2845         rule__ConnectionUpdate__Group__5
2846 ;
2847 finally {
2848         restoreStackSize(stackSize);
2849 }
2850
2851 rule__ConnectionUpdate__Group__4__Impl
2852     @init {
2853                 int stackSize = keepStackSize();
2854     }
2855 :
2856 (
2857 { before(grammarAccess.getConnectionUpdateAccess().getGroup_4()); }
2858 (rule__ConnectionUpdate__Group_4__0)?
2859 { after(grammarAccess.getConnectionUpdateAccess().getGroup_4()); }
2860 )
2861
2862 ;
2863 finally {
2864         restoreStackSize(stackSize);
2865 }
2866
2867
2868 rule__ConnectionUpdate__Group__5
2869     @init {
2870                 int stackSize = keepStackSize();
2871     }
2872 :
2873         rule__ConnectionUpdate__Group__5__Impl
2874         rule__ConnectionUpdate__Group__6
2875 ;
2876 finally {
2877         restoreStackSize(stackSize);
2878 }
2879
2880 rule__ConnectionUpdate__Group__5__Impl
2881     @init {
2882                 int stackSize = keepStackSize();
2883     }
2884 :
2885 (
2886 { before(grammarAccess.getConnectionUpdateAccess().getPropertyParserRuleCall_5()); }
2887 (       ruleProperty)?
2888 { after(grammarAccess.getConnectionUpdateAccess().getPropertyParserRuleCall_5()); }
2889 )
2890
2891 ;
2892 finally {
2893         restoreStackSize(stackSize);
2894 }
2895
2896
2897 rule__ConnectionUpdate__Group__6
2898     @init {
2899                 int stackSize = keepStackSize();
2900     }
2901 :
2902         rule__ConnectionUpdate__Group__6__Impl
2903 ;
2904 finally {
2905         restoreStackSize(stackSize);
2906 }
2907
2908 rule__ConnectionUpdate__Group__6__Impl
2909     @init {
2910                 int stackSize = keepStackSize();
2911     }
2912 :
2913 (
2914 { before(grammarAccess.getConnectionUpdateAccess().getSemicolonKeyword_6()); }
2915
2916         ';'
2917
2918 { after(grammarAccess.getConnectionUpdateAccess().getSemicolonKeyword_6()); }
2919 )
2920
2921 ;
2922 finally {
2923         restoreStackSize(stackSize);
2924 }
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941 rule__ConnectionUpdate__Group_3__0
2942     @init {
2943                 int stackSize = keepStackSize();
2944     }
2945 :
2946         rule__ConnectionUpdate__Group_3__0__Impl
2947         rule__ConnectionUpdate__Group_3__1
2948 ;
2949 finally {
2950         restoreStackSize(stackSize);
2951 }
2952
2953 rule__ConnectionUpdate__Group_3__0__Impl
2954     @init {
2955                 int stackSize = keepStackSize();
2956     }
2957 :
2958 (
2959 { before(grammarAccess.getConnectionUpdateAccess().getTypeKeyword_3_0()); }
2960
2961         'Type'
2962
2963 { after(grammarAccess.getConnectionUpdateAccess().getTypeKeyword_3_0()); }
2964 )
2965
2966 ;
2967 finally {
2968         restoreStackSize(stackSize);
2969 }
2970
2971
2972 rule__ConnectionUpdate__Group_3__1
2973     @init {
2974                 int stackSize = keepStackSize();
2975     }
2976 :
2977         rule__ConnectionUpdate__Group_3__1__Impl
2978 ;
2979 finally {
2980         restoreStackSize(stackSize);
2981 }
2982
2983 rule__ConnectionUpdate__Group_3__1__Impl
2984     @init {
2985                 int stackSize = keepStackSize();
2986     }
2987 :
2988 (
2989 { before(grammarAccess.getConnectionUpdateAccess().getNemoIdTerminalRuleCall_3_1()); }
2990         RULE_NEMOID
2991 { after(grammarAccess.getConnectionUpdateAccess().getNemoIdTerminalRuleCall_3_1()); }
2992 )
2993
2994 ;
2995 finally {
2996         restoreStackSize(stackSize);
2997 }
2998
2999
3000
3001
3002
3003
3004 rule__ConnectionUpdate__Group_4__0
3005     @init {
3006                 int stackSize = keepStackSize();
3007     }
3008 :
3009         rule__ConnectionUpdate__Group_4__0__Impl
3010         rule__ConnectionUpdate__Group_4__1
3011 ;
3012 finally {
3013         restoreStackSize(stackSize);
3014 }
3015
3016 rule__ConnectionUpdate__Group_4__0__Impl
3017     @init {
3018                 int stackSize = keepStackSize();
3019     }
3020 :
3021 (
3022 { before(grammarAccess.getConnectionUpdateAccess().getEndnodesKeyword_4_0()); }
3023
3024         'Endnodes'
3025
3026 { after(grammarAccess.getConnectionUpdateAccess().getEndnodesKeyword_4_0()); }
3027 )
3028
3029 ;
3030 finally {
3031         restoreStackSize(stackSize);
3032 }
3033
3034
3035 rule__ConnectionUpdate__Group_4__1
3036     @init {
3037                 int stackSize = keepStackSize();
3038     }
3039 :
3040         rule__ConnectionUpdate__Group_4__1__Impl
3041         rule__ConnectionUpdate__Group_4__2
3042 ;
3043 finally {
3044         restoreStackSize(stackSize);
3045 }
3046
3047 rule__ConnectionUpdate__Group_4__1__Impl
3048     @init {
3049                 int stackSize = keepStackSize();
3050     }
3051 :
3052 (
3053 { before(grammarAccess.getConnectionUpdateAccess().getEndnodeAssignment_4_1()); }
3054 (rule__ConnectionUpdate__EndnodeAssignment_4_1)
3055 { after(grammarAccess.getConnectionUpdateAccess().getEndnodeAssignment_4_1()); }
3056 )
3057
3058 ;
3059 finally {
3060         restoreStackSize(stackSize);
3061 }
3062
3063
3064 rule__ConnectionUpdate__Group_4__2
3065     @init {
3066                 int stackSize = keepStackSize();
3067     }
3068 :
3069         rule__ConnectionUpdate__Group_4__2__Impl
3070 ;
3071 finally {
3072         restoreStackSize(stackSize);
3073 }
3074
3075 rule__ConnectionUpdate__Group_4__2__Impl
3076     @init {
3077                 int stackSize = keepStackSize();
3078     }
3079 :
3080 (
3081 { before(grammarAccess.getConnectionUpdateAccess().getGroup_4_2()); }
3082 (rule__ConnectionUpdate__Group_4_2__0)*
3083 { after(grammarAccess.getConnectionUpdateAccess().getGroup_4_2()); }
3084 )
3085
3086 ;
3087 finally {
3088         restoreStackSize(stackSize);
3089 }
3090
3091
3092
3093
3094
3095
3096
3097
3098 rule__ConnectionUpdate__Group_4_2__0
3099     @init {
3100                 int stackSize = keepStackSize();
3101     }
3102 :
3103         rule__ConnectionUpdate__Group_4_2__0__Impl
3104         rule__ConnectionUpdate__Group_4_2__1
3105 ;
3106 finally {
3107         restoreStackSize(stackSize);
3108 }
3109
3110 rule__ConnectionUpdate__Group_4_2__0__Impl
3111     @init {
3112                 int stackSize = keepStackSize();
3113     }
3114 :
3115 (
3116 { before(grammarAccess.getConnectionUpdateAccess().getCommaKeyword_4_2_0()); }
3117
3118         ','
3119
3120 { after(grammarAccess.getConnectionUpdateAccess().getCommaKeyword_4_2_0()); }
3121 )
3122
3123 ;
3124 finally {
3125         restoreStackSize(stackSize);
3126 }
3127
3128
3129 rule__ConnectionUpdate__Group_4_2__1
3130     @init {
3131                 int stackSize = keepStackSize();
3132     }
3133 :
3134         rule__ConnectionUpdate__Group_4_2__1__Impl
3135 ;
3136 finally {
3137         restoreStackSize(stackSize);
3138 }
3139
3140 rule__ConnectionUpdate__Group_4_2__1__Impl
3141     @init {
3142                 int stackSize = keepStackSize();
3143     }
3144 :
3145 (
3146 { before(grammarAccess.getConnectionUpdateAccess().getEndnodeAssignment_4_2_1()); }
3147 (rule__ConnectionUpdate__EndnodeAssignment_4_2_1)
3148 { after(grammarAccess.getConnectionUpdateAccess().getEndnodeAssignment_4_2_1()); }
3149 )
3150
3151 ;
3152 finally {
3153         restoreStackSize(stackSize);
3154 }
3155
3156
3157
3158
3159
3160
3161 rule__Flow__Group__0
3162     @init {
3163                 int stackSize = keepStackSize();
3164     }
3165 :
3166         rule__Flow__Group__0__Impl
3167         rule__Flow__Group__1
3168 ;
3169 finally {
3170         restoreStackSize(stackSize);
3171 }
3172
3173 rule__Flow__Group__0__Impl
3174     @init {
3175                 int stackSize = keepStackSize();
3176     }
3177 :
3178 (
3179 { before(grammarAccess.getFlowAccess().getCREATEKeyword_0()); }
3180
3181         'CREATE'
3182
3183 { after(grammarAccess.getFlowAccess().getCREATEKeyword_0()); }
3184 )
3185
3186 ;
3187 finally {
3188         restoreStackSize(stackSize);
3189 }
3190
3191
3192 rule__Flow__Group__1
3193     @init {
3194                 int stackSize = keepStackSize();
3195     }
3196 :
3197         rule__Flow__Group__1__Impl
3198         rule__Flow__Group__2
3199 ;
3200 finally {
3201         restoreStackSize(stackSize);
3202 }
3203
3204 rule__Flow__Group__1__Impl
3205     @init {
3206                 int stackSize = keepStackSize();
3207     }
3208 :
3209 (
3210 { before(grammarAccess.getFlowAccess().getFlowKeyword_1()); }
3211
3212         'Flow'
3213
3214 { after(grammarAccess.getFlowAccess().getFlowKeyword_1()); }
3215 )
3216
3217 ;
3218 finally {
3219         restoreStackSize(stackSize);
3220 }
3221
3222
3223 rule__Flow__Group__2
3224     @init {
3225                 int stackSize = keepStackSize();
3226     }
3227 :
3228         rule__Flow__Group__2__Impl
3229         rule__Flow__Group__3
3230 ;
3231 finally {
3232         restoreStackSize(stackSize);
3233 }
3234
3235 rule__Flow__Group__2__Impl
3236     @init {
3237                 int stackSize = keepStackSize();
3238     }
3239 :
3240 (
3241 { before(grammarAccess.getFlowAccess().getNameAssignment_2()); }
3242 (rule__Flow__NameAssignment_2)
3243 { after(grammarAccess.getFlowAccess().getNameAssignment_2()); }
3244 )
3245
3246 ;
3247 finally {
3248         restoreStackSize(stackSize);
3249 }
3250
3251
3252 rule__Flow__Group__3
3253     @init {
3254                 int stackSize = keepStackSize();
3255     }
3256 :
3257         rule__Flow__Group__3__Impl
3258         rule__Flow__Group__4
3259 ;
3260 finally {
3261         restoreStackSize(stackSize);
3262 }
3263
3264 rule__Flow__Group__3__Impl
3265     @init {
3266                 int stackSize = keepStackSize();
3267     }
3268 :
3269 (
3270 { before(grammarAccess.getFlowAccess().getMatchesParserRuleCall_3()); }
3271 (       ruleMatches)?
3272 { after(grammarAccess.getFlowAccess().getMatchesParserRuleCall_3()); }
3273 )
3274
3275 ;
3276 finally {
3277         restoreStackSize(stackSize);
3278 }
3279
3280
3281 rule__Flow__Group__4
3282     @init {
3283                 int stackSize = keepStackSize();
3284     }
3285 :
3286         rule__Flow__Group__4__Impl
3287 ;
3288 finally {
3289         restoreStackSize(stackSize);
3290 }
3291
3292 rule__Flow__Group__4__Impl
3293     @init {
3294                 int stackSize = keepStackSize();
3295     }
3296 :
3297 (
3298 { before(grammarAccess.getFlowAccess().getSemicolonKeyword_4()); }
3299
3300         ';'
3301
3302 { after(grammarAccess.getFlowAccess().getSemicolonKeyword_4()); }
3303 )
3304
3305 ;
3306 finally {
3307         restoreStackSize(stackSize);
3308 }
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321 rule__FlowUpdate__Group__0
3322     @init {
3323                 int stackSize = keepStackSize();
3324     }
3325 :
3326         rule__FlowUpdate__Group__0__Impl
3327         rule__FlowUpdate__Group__1
3328 ;
3329 finally {
3330         restoreStackSize(stackSize);
3331 }
3332
3333 rule__FlowUpdate__Group__0__Impl
3334     @init {
3335                 int stackSize = keepStackSize();
3336     }
3337 :
3338 (
3339 { before(grammarAccess.getFlowUpdateAccess().getAlternatives_0()); }
3340 (rule__FlowUpdate__Alternatives_0)
3341 { after(grammarAccess.getFlowUpdateAccess().getAlternatives_0()); }
3342 )
3343
3344 ;
3345 finally {
3346         restoreStackSize(stackSize);
3347 }
3348
3349
3350 rule__FlowUpdate__Group__1
3351     @init {
3352                 int stackSize = keepStackSize();
3353     }
3354 :
3355         rule__FlowUpdate__Group__1__Impl
3356         rule__FlowUpdate__Group__2
3357 ;
3358 finally {
3359         restoreStackSize(stackSize);
3360 }
3361
3362 rule__FlowUpdate__Group__1__Impl
3363     @init {
3364                 int stackSize = keepStackSize();
3365     }
3366 :
3367 (
3368 { before(grammarAccess.getFlowUpdateAccess().getFlowKeyword_1()); }
3369
3370         'Flow'
3371
3372 { after(grammarAccess.getFlowUpdateAccess().getFlowKeyword_1()); }
3373 )
3374
3375 ;
3376 finally {
3377         restoreStackSize(stackSize);
3378 }
3379
3380
3381 rule__FlowUpdate__Group__2
3382     @init {
3383                 int stackSize = keepStackSize();
3384     }
3385 :
3386         rule__FlowUpdate__Group__2__Impl
3387         rule__FlowUpdate__Group__3
3388 ;
3389 finally {
3390         restoreStackSize(stackSize);
3391 }
3392
3393 rule__FlowUpdate__Group__2__Impl
3394     @init {
3395                 int stackSize = keepStackSize();
3396     }
3397 :
3398 (
3399 { before(grammarAccess.getFlowUpdateAccess().getFlowIdAssignment_2()); }
3400 (rule__FlowUpdate__FlowIdAssignment_2)
3401 { after(grammarAccess.getFlowUpdateAccess().getFlowIdAssignment_2()); }
3402 )
3403
3404 ;
3405 finally {
3406         restoreStackSize(stackSize);
3407 }
3408
3409
3410 rule__FlowUpdate__Group__3
3411     @init {
3412                 int stackSize = keepStackSize();
3413     }
3414 :
3415         rule__FlowUpdate__Group__3__Impl
3416         rule__FlowUpdate__Group__4
3417 ;
3418 finally {
3419         restoreStackSize(stackSize);
3420 }
3421
3422 rule__FlowUpdate__Group__3__Impl
3423     @init {
3424                 int stackSize = keepStackSize();
3425     }
3426 :
3427 (
3428 { before(grammarAccess.getFlowUpdateAccess().getMatchesParserRuleCall_3()); }
3429 (       ruleMatches)?
3430 { after(grammarAccess.getFlowUpdateAccess().getMatchesParserRuleCall_3()); }
3431 )
3432
3433 ;
3434 finally {
3435         restoreStackSize(stackSize);
3436 }
3437
3438
3439 rule__FlowUpdate__Group__4
3440     @init {
3441                 int stackSize = keepStackSize();
3442     }
3443 :
3444         rule__FlowUpdate__Group__4__Impl
3445 ;
3446 finally {
3447         restoreStackSize(stackSize);
3448 }
3449
3450 rule__FlowUpdate__Group__4__Impl
3451     @init {
3452                 int stackSize = keepStackSize();
3453     }
3454 :
3455 (
3456 { before(grammarAccess.getFlowUpdateAccess().getSemicolonKeyword_4()); }
3457
3458         ';'
3459
3460 { after(grammarAccess.getFlowUpdateAccess().getSemicolonKeyword_4()); }
3461 )
3462
3463 ;
3464 finally {
3465         restoreStackSize(stackSize);
3466 }
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479 rule__Matches__Group__0
3480     @init {
3481                 int stackSize = keepStackSize();
3482     }
3483 :
3484         rule__Matches__Group__0__Impl
3485         rule__Matches__Group__1
3486 ;
3487 finally {
3488         restoreStackSize(stackSize);
3489 }
3490
3491 rule__Matches__Group__0__Impl
3492     @init {
3493                 int stackSize = keepStackSize();
3494     }
3495 :
3496 (
3497 { before(grammarAccess.getMatchesAccess().getMatchKeyword_0()); }
3498
3499         'Match'
3500
3501 { after(grammarAccess.getMatchesAccess().getMatchKeyword_0()); }
3502 )
3503
3504 ;
3505 finally {
3506         restoreStackSize(stackSize);
3507 }
3508
3509
3510 rule__Matches__Group__1
3511     @init {
3512                 int stackSize = keepStackSize();
3513     }
3514 :
3515         rule__Matches__Group__1__Impl
3516         rule__Matches__Group__2
3517 ;
3518 finally {
3519         restoreStackSize(stackSize);
3520 }
3521
3522 rule__Matches__Group__1__Impl
3523     @init {
3524                 int stackSize = keepStackSize();
3525     }
3526 :
3527 (
3528 { before(grammarAccess.getMatchesAccess().getMatchParserRuleCall_1()); }
3529         ruleMatch
3530 { after(grammarAccess.getMatchesAccess().getMatchParserRuleCall_1()); }
3531 )
3532
3533 ;
3534 finally {
3535         restoreStackSize(stackSize);
3536 }
3537
3538
3539 rule__Matches__Group__2
3540     @init {
3541                 int stackSize = keepStackSize();
3542     }
3543 :
3544         rule__Matches__Group__2__Impl
3545 ;
3546 finally {
3547         restoreStackSize(stackSize);
3548 }
3549
3550 rule__Matches__Group__2__Impl
3551     @init {
3552                 int stackSize = keepStackSize();
3553     }
3554 :
3555 (
3556 { before(grammarAccess.getMatchesAccess().getGroup_2()); }
3557 (rule__Matches__Group_2__0)*
3558 { after(grammarAccess.getMatchesAccess().getGroup_2()); }
3559 )
3560
3561 ;
3562 finally {
3563         restoreStackSize(stackSize);
3564 }
3565
3566
3567
3568
3569
3570
3571
3572
3573 rule__Matches__Group_2__0
3574     @init {
3575                 int stackSize = keepStackSize();
3576     }
3577 :
3578         rule__Matches__Group_2__0__Impl
3579         rule__Matches__Group_2__1
3580 ;
3581 finally {
3582         restoreStackSize(stackSize);
3583 }
3584
3585 rule__Matches__Group_2__0__Impl
3586     @init {
3587                 int stackSize = keepStackSize();
3588     }
3589 :
3590 (
3591 { before(grammarAccess.getMatchesAccess().getCommaKeyword_2_0()); }
3592
3593         ','
3594
3595 { after(grammarAccess.getMatchesAccess().getCommaKeyword_2_0()); }
3596 )
3597
3598 ;
3599 finally {
3600         restoreStackSize(stackSize);
3601 }
3602
3603
3604 rule__Matches__Group_2__1
3605     @init {
3606                 int stackSize = keepStackSize();
3607     }
3608 :
3609         rule__Matches__Group_2__1__Impl
3610 ;
3611 finally {
3612         restoreStackSize(stackSize);
3613 }
3614
3615 rule__Matches__Group_2__1__Impl
3616     @init {
3617                 int stackSize = keepStackSize();
3618     }
3619 :
3620 (
3621 { before(grammarAccess.getMatchesAccess().getMatchParserRuleCall_2_1()); }
3622         ruleMatch
3623 { after(grammarAccess.getMatchesAccess().getMatchParserRuleCall_2_1()); }
3624 )
3625
3626 ;
3627 finally {
3628         restoreStackSize(stackSize);
3629 }
3630
3631
3632
3633
3634
3635
3636 rule__Match__Group__0
3637     @init {
3638                 int stackSize = keepStackSize();
3639     }
3640 :
3641         rule__Match__Group__0__Impl
3642         rule__Match__Group__1
3643 ;
3644 finally {
3645         restoreStackSize(stackSize);
3646 }
3647
3648 rule__Match__Group__0__Impl
3649     @init {
3650                 int stackSize = keepStackSize();
3651     }
3652 :
3653 (
3654 { before(grammarAccess.getMatchAccess().getNemoIdTerminalRuleCall_0()); }
3655         RULE_NEMOID
3656 { after(grammarAccess.getMatchAccess().getNemoIdTerminalRuleCall_0()); }
3657 )
3658
3659 ;
3660 finally {
3661         restoreStackSize(stackSize);
3662 }
3663
3664
3665 rule__Match__Group__1
3666     @init {
3667                 int stackSize = keepStackSize();
3668     }
3669 :
3670         rule__Match__Group__1__Impl
3671         rule__Match__Group__2
3672 ;
3673 finally {
3674         restoreStackSize(stackSize);
3675 }
3676
3677 rule__Match__Group__1__Impl
3678     @init {
3679                 int stackSize = keepStackSize();
3680     }
3681 :
3682 (
3683 { before(grammarAccess.getMatchAccess().getColonKeyword_1()); }
3684
3685         ':'
3686
3687 { after(grammarAccess.getMatchAccess().getColonKeyword_1()); }
3688 )
3689
3690 ;
3691 finally {
3692         restoreStackSize(stackSize);
3693 }
3694
3695
3696 rule__Match__Group__2
3697     @init {
3698                 int stackSize = keepStackSize();
3699     }
3700 :
3701         rule__Match__Group__2__Impl
3702 ;
3703 finally {
3704         restoreStackSize(stackSize);
3705 }
3706
3707 rule__Match__Group__2__Impl
3708     @init {
3709                 int stackSize = keepStackSize();
3710     }
3711 :
3712 (
3713 { before(grammarAccess.getMatchAccess().getSTRINGTerminalRuleCall_2()); }
3714         RULE_STRING
3715 { after(grammarAccess.getMatchAccess().getSTRINGTerminalRuleCall_2()); }
3716 )
3717
3718 ;
3719 finally {
3720         restoreStackSize(stackSize);
3721 }
3722
3723
3724
3725
3726
3727
3728
3729
3730 rule__Operation__Group__0
3731     @init {
3732                 int stackSize = keepStackSize();
3733     }
3734 :
3735         rule__Operation__Group__0__Impl
3736         rule__Operation__Group__1
3737 ;
3738 finally {
3739         restoreStackSize(stackSize);
3740 }
3741
3742 rule__Operation__Group__0__Impl
3743     @init {
3744                 int stackSize = keepStackSize();
3745     }
3746 :
3747 (
3748 { before(grammarAccess.getOperationAccess().getCREATEKeyword_0()); }
3749
3750         'CREATE'
3751
3752 { after(grammarAccess.getOperationAccess().getCREATEKeyword_0()); }
3753 )
3754
3755 ;
3756 finally {
3757         restoreStackSize(stackSize);
3758 }
3759
3760
3761 rule__Operation__Group__1
3762     @init {
3763                 int stackSize = keepStackSize();
3764     }
3765 :
3766         rule__Operation__Group__1__Impl
3767         rule__Operation__Group__2
3768 ;
3769 finally {
3770         restoreStackSize(stackSize);
3771 }
3772
3773 rule__Operation__Group__1__Impl
3774     @init {
3775                 int stackSize = keepStackSize();
3776     }
3777 :
3778 (
3779 { before(grammarAccess.getOperationAccess().getOperationKeyword_1()); }
3780
3781         'Operation'
3782
3783 { after(grammarAccess.getOperationAccess().getOperationKeyword_1()); }
3784 )
3785
3786 ;
3787 finally {
3788         restoreStackSize(stackSize);
3789 }
3790
3791
3792 rule__Operation__Group__2
3793     @init {
3794                 int stackSize = keepStackSize();
3795     }
3796 :
3797         rule__Operation__Group__2__Impl
3798         rule__Operation__Group__3
3799 ;
3800 finally {
3801         restoreStackSize(stackSize);
3802 }
3803
3804 rule__Operation__Group__2__Impl
3805     @init {
3806                 int stackSize = keepStackSize();
3807     }
3808 :
3809 (
3810 { before(grammarAccess.getOperationAccess().getNameAssignment_2()); }
3811 (rule__Operation__NameAssignment_2)
3812 { after(grammarAccess.getOperationAccess().getNameAssignment_2()); }
3813 )
3814
3815 ;
3816 finally {
3817         restoreStackSize(stackSize);
3818 }
3819
3820
3821 rule__Operation__Group__3
3822     @init {
3823                 int stackSize = keepStackSize();
3824     }
3825 :
3826         rule__Operation__Group__3__Impl
3827         rule__Operation__Group__4
3828 ;
3829 finally {
3830         restoreStackSize(stackSize);
3831 }
3832
3833 rule__Operation__Group__3__Impl
3834     @init {
3835                 int stackSize = keepStackSize();
3836     }
3837 :
3838 (
3839 { before(grammarAccess.getOperationAccess().getGroup_3()); }
3840 (rule__Operation__Group_3__0)?
3841 { after(grammarAccess.getOperationAccess().getGroup_3()); }
3842 )
3843
3844 ;
3845 finally {
3846         restoreStackSize(stackSize);
3847 }
3848
3849
3850 rule__Operation__Group__4
3851     @init {
3852                 int stackSize = keepStackSize();
3853     }
3854 :
3855         rule__Operation__Group__4__Impl
3856         rule__Operation__Group__5
3857 ;
3858 finally {
3859         restoreStackSize(stackSize);
3860 }
3861
3862 rule__Operation__Group__4__Impl
3863     @init {
3864                 int stackSize = keepStackSize();
3865     }
3866 :
3867 (
3868 { before(grammarAccess.getOperationAccess().getTargetKeyword_4()); }
3869
3870         'Target'
3871
3872 { after(grammarAccess.getOperationAccess().getTargetKeyword_4()); }
3873 )
3874
3875 ;
3876 finally {
3877         restoreStackSize(stackSize);
3878 }
3879
3880
3881 rule__Operation__Group__5
3882     @init {
3883                 int stackSize = keepStackSize();
3884     }
3885 :
3886         rule__Operation__Group__5__Impl
3887         rule__Operation__Group__6
3888 ;
3889 finally {
3890         restoreStackSize(stackSize);
3891 }
3892
3893 rule__Operation__Group__5__Impl
3894     @init {
3895                 int stackSize = keepStackSize();
3896     }
3897 :
3898 (
3899 { before(grammarAccess.getOperationAccess().getTargetIdAssignment_5()); }
3900 (rule__Operation__TargetIdAssignment_5)
3901 { after(grammarAccess.getOperationAccess().getTargetIdAssignment_5()); }
3902 )
3903
3904 ;
3905 finally {
3906         restoreStackSize(stackSize);
3907 }
3908
3909
3910 rule__Operation__Group__6
3911     @init {
3912                 int stackSize = keepStackSize();
3913     }
3914 :
3915         rule__Operation__Group__6__Impl
3916         rule__Operation__Group__7
3917 ;
3918 finally {
3919         restoreStackSize(stackSize);
3920 }
3921
3922 rule__Operation__Group__6__Impl
3923     @init {
3924                 int stackSize = keepStackSize();
3925     }
3926 :
3927 (
3928 { before(grammarAccess.getOperationAccess().getConditionParserRuleCall_6()); }
3929 (       ruleCondition)?
3930 { after(grammarAccess.getOperationAccess().getConditionParserRuleCall_6()); }
3931 )
3932
3933 ;
3934 finally {
3935         restoreStackSize(stackSize);
3936 }
3937
3938
3939 rule__Operation__Group__7
3940     @init {
3941                 int stackSize = keepStackSize();
3942     }
3943 :
3944         rule__Operation__Group__7__Impl
3945         rule__Operation__Group__8
3946 ;
3947 finally {
3948         restoreStackSize(stackSize);
3949 }
3950
3951 rule__Operation__Group__7__Impl
3952     @init {
3953                 int stackSize = keepStackSize();
3954     }
3955 :
3956 (
3957 { before(grammarAccess.getOperationAccess().getActionKeyword_7()); }
3958
3959         'Action'
3960
3961 { after(grammarAccess.getOperationAccess().getActionKeyword_7()); }
3962 )
3963
3964 ;
3965 finally {
3966         restoreStackSize(stackSize);
3967 }
3968
3969
3970 rule__Operation__Group__8
3971     @init {
3972                 int stackSize = keepStackSize();
3973     }
3974 :
3975         rule__Operation__Group__8__Impl
3976         rule__Operation__Group__9
3977 ;
3978 finally {
3979         restoreStackSize(stackSize);
3980 }
3981
3982 rule__Operation__Group__8__Impl
3983     @init {
3984                 int stackSize = keepStackSize();
3985     }
3986 :
3987 (
3988 { before(grammarAccess.getOperationAccess().getAlternatives_8()); }
3989 (rule__Operation__Alternatives_8)
3990 { after(grammarAccess.getOperationAccess().getAlternatives_8()); }
3991 )
3992
3993 ;
3994 finally {
3995         restoreStackSize(stackSize);
3996 }
3997
3998
3999 rule__Operation__Group__9
4000     @init {
4001                 int stackSize = keepStackSize();
4002     }
4003 :
4004         rule__Operation__Group__9__Impl
4005 ;
4006 finally {
4007         restoreStackSize(stackSize);
4008 }
4009
4010 rule__Operation__Group__9__Impl
4011     @init {
4012                 int stackSize = keepStackSize();
4013     }
4014 :
4015 (
4016 { before(grammarAccess.getOperationAccess().getSemicolonKeyword_9()); }
4017
4018         ';'
4019
4020 { after(grammarAccess.getOperationAccess().getSemicolonKeyword_9()); }
4021 )
4022
4023 ;
4024 finally {
4025         restoreStackSize(stackSize);
4026 }
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049 rule__Operation__Group_3__0
4050     @init {
4051                 int stackSize = keepStackSize();
4052     }
4053 :
4054         rule__Operation__Group_3__0__Impl
4055         rule__Operation__Group_3__1
4056 ;
4057 finally {
4058         restoreStackSize(stackSize);
4059 }
4060
4061 rule__Operation__Group_3__0__Impl
4062     @init {
4063                 int stackSize = keepStackSize();
4064     }
4065 :
4066 (
4067 { before(grammarAccess.getOperationAccess().getPriorityKeyword_3_0()); }
4068
4069         'Priority'
4070
4071 { after(grammarAccess.getOperationAccess().getPriorityKeyword_3_0()); }
4072 )
4073
4074 ;
4075 finally {
4076         restoreStackSize(stackSize);
4077 }
4078
4079
4080 rule__Operation__Group_3__1
4081     @init {
4082                 int stackSize = keepStackSize();
4083     }
4084 :
4085         rule__Operation__Group_3__1__Impl
4086 ;
4087 finally {
4088         restoreStackSize(stackSize);
4089 }
4090
4091 rule__Operation__Group_3__1__Impl
4092     @init {
4093                 int stackSize = keepStackSize();
4094     }
4095 :
4096 (
4097 { before(grammarAccess.getOperationAccess().getValueAssignment_3_1()); }
4098 (rule__Operation__ValueAssignment_3_1)
4099 { after(grammarAccess.getOperationAccess().getValueAssignment_3_1()); }
4100 )
4101
4102 ;
4103 finally {
4104         restoreStackSize(stackSize);
4105 }
4106
4107
4108
4109
4110
4111
4112 rule__Operation__Group_8_1__0
4113     @init {
4114                 int stackSize = keepStackSize();
4115     }
4116 :
4117         rule__Operation__Group_8_1__0__Impl
4118         rule__Operation__Group_8_1__1
4119 ;
4120 finally {
4121         restoreStackSize(stackSize);
4122 }
4123
4124 rule__Operation__Group_8_1__0__Impl
4125     @init {
4126                 int stackSize = keepStackSize();
4127     }
4128 :
4129 (
4130 { before(grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_1_0()); }
4131         RULE_NEMOID
4132 { after(grammarAccess.getOperationAccess().getNemoIdTerminalRuleCall_8_1_0()); }
4133 )
4134
4135 ;
4136 finally {
4137         restoreStackSize(stackSize);
4138 }
4139
4140
4141 rule__Operation__Group_8_1__1
4142     @init {
4143                 int stackSize = keepStackSize();
4144     }
4145 :
4146         rule__Operation__Group_8_1__1__Impl
4147         rule__Operation__Group_8_1__2
4148 ;
4149 finally {
4150         restoreStackSize(stackSize);
4151 }
4152
4153 rule__Operation__Group_8_1__1__Impl
4154     @init {
4155                 int stackSize = keepStackSize();
4156     }
4157 :
4158 (
4159 { before(grammarAccess.getOperationAccess().getColonKeyword_8_1_1()); }
4160
4161         ':'
4162
4163 { after(grammarAccess.getOperationAccess().getColonKeyword_8_1_1()); }
4164 )
4165
4166 ;
4167 finally {
4168         restoreStackSize(stackSize);
4169 }
4170
4171
4172 rule__Operation__Group_8_1__2
4173     @init {
4174                 int stackSize = keepStackSize();
4175     }
4176 :
4177         rule__Operation__Group_8_1__2__Impl
4178 ;
4179 finally {
4180         restoreStackSize(stackSize);
4181 }
4182
4183 rule__Operation__Group_8_1__2__Impl
4184     @init {
4185                 int stackSize = keepStackSize();
4186     }
4187 :
4188 (
4189 { before(grammarAccess.getOperationAccess().getTargetNodeAssignment_8_1_2()); }
4190 (rule__Operation__TargetNodeAssignment_8_1_2)
4191 { after(grammarAccess.getOperationAccess().getTargetNodeAssignment_8_1_2()); }
4192 )
4193
4194 ;
4195 finally {
4196         restoreStackSize(stackSize);
4197 }
4198
4199
4200
4201
4202
4203
4204
4205
4206 rule__Condition__Group__0
4207     @init {
4208                 int stackSize = keepStackSize();
4209     }
4210 :
4211         rule__Condition__Group__0__Impl
4212         rule__Condition__Group__1
4213 ;
4214 finally {
4215         restoreStackSize(stackSize);
4216 }
4217
4218 rule__Condition__Group__0__Impl
4219     @init {
4220                 int stackSize = keepStackSize();
4221     }
4222 :
4223 (
4224 { before(grammarAccess.getConditionAccess().getConditionKeyword_0()); }
4225
4226         'Condition'
4227
4228 { after(grammarAccess.getConditionAccess().getConditionKeyword_0()); }
4229 )
4230
4231 ;
4232 finally {
4233         restoreStackSize(stackSize);
4234 }
4235
4236
4237 rule__Condition__Group__1
4238     @init {
4239                 int stackSize = keepStackSize();
4240     }
4241 :
4242         rule__Condition__Group__1__Impl
4243         rule__Condition__Group__2
4244 ;
4245 finally {
4246         restoreStackSize(stackSize);
4247 }
4248
4249 rule__Condition__Group__1__Impl
4250     @init {
4251                 int stackSize = keepStackSize();
4252     }
4253 :
4254 (
4255 { before(grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_1()); }
4256         RULE_STRING
4257 { after(grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_1()); }
4258 )
4259
4260 ;
4261 finally {
4262         restoreStackSize(stackSize);
4263 }
4264
4265
4266 rule__Condition__Group__2
4267     @init {
4268                 int stackSize = keepStackSize();
4269     }
4270 :
4271         rule__Condition__Group__2__Impl
4272 ;
4273 finally {
4274         restoreStackSize(stackSize);
4275 }
4276
4277 rule__Condition__Group__2__Impl
4278     @init {
4279                 int stackSize = keepStackSize();
4280     }
4281 :
4282 (
4283 { before(grammarAccess.getConditionAccess().getGroup_2()); }
4284 (rule__Condition__Group_2__0)*
4285 { after(grammarAccess.getConditionAccess().getGroup_2()); }
4286 )
4287
4288 ;
4289 finally {
4290         restoreStackSize(stackSize);
4291 }
4292
4293
4294
4295
4296
4297
4298
4299
4300 rule__Condition__Group_2__0
4301     @init {
4302                 int stackSize = keepStackSize();
4303     }
4304 :
4305         rule__Condition__Group_2__0__Impl
4306         rule__Condition__Group_2__1
4307 ;
4308 finally {
4309         restoreStackSize(stackSize);
4310 }
4311
4312 rule__Condition__Group_2__0__Impl
4313     @init {
4314                 int stackSize = keepStackSize();
4315     }
4316 :
4317 (
4318 { before(grammarAccess.getConditionAccess().getCommaKeyword_2_0()); }
4319
4320         ','
4321
4322 { after(grammarAccess.getConditionAccess().getCommaKeyword_2_0()); }
4323 )
4324
4325 ;
4326 finally {
4327         restoreStackSize(stackSize);
4328 }
4329
4330
4331 rule__Condition__Group_2__1
4332     @init {
4333                 int stackSize = keepStackSize();
4334     }
4335 :
4336         rule__Condition__Group_2__1__Impl
4337 ;
4338 finally {
4339         restoreStackSize(stackSize);
4340 }
4341
4342 rule__Condition__Group_2__1__Impl
4343     @init {
4344                 int stackSize = keepStackSize();
4345     }
4346 :
4347 (
4348 { before(grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_2_1()); }
4349         RULE_STRING
4350 { after(grammarAccess.getConditionAccess().getSTRINGTerminalRuleCall_2_1()); }
4351 )
4352
4353 ;
4354 finally {
4355         restoreStackSize(stackSize);
4356 }
4357
4358
4359
4360
4361
4362
4363 rule__Property__Group__0
4364     @init {
4365                 int stackSize = keepStackSize();
4366     }
4367 :
4368         rule__Property__Group__0__Impl
4369         rule__Property__Group__1
4370 ;
4371 finally {
4372         restoreStackSize(stackSize);
4373 }
4374
4375 rule__Property__Group__0__Impl
4376     @init {
4377                 int stackSize = keepStackSize();
4378     }
4379 :
4380 (
4381 { before(grammarAccess.getPropertyAccess().getPropertyKeyword_0()); }
4382
4383         'Property '
4384
4385 { after(grammarAccess.getPropertyAccess().getPropertyKeyword_0()); }
4386 )
4387
4388 ;
4389 finally {
4390         restoreStackSize(stackSize);
4391 }
4392
4393
4394 rule__Property__Group__1
4395     @init {
4396                 int stackSize = keepStackSize();
4397     }
4398 :
4399         rule__Property__Group__1__Impl
4400         rule__Property__Group__2
4401 ;
4402 finally {
4403         restoreStackSize(stackSize);
4404 }
4405
4406 rule__Property__Group__1__Impl
4407     @init {
4408                 int stackSize = keepStackSize();
4409     }
4410 :
4411 (
4412 { before(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_1()); }
4413         ruleOneProperty
4414 { after(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_1()); }
4415 )
4416
4417 ;
4418 finally {
4419         restoreStackSize(stackSize);
4420 }
4421
4422
4423 rule__Property__Group__2
4424     @init {
4425                 int stackSize = keepStackSize();
4426     }
4427 :
4428         rule__Property__Group__2__Impl
4429 ;
4430 finally {
4431         restoreStackSize(stackSize);
4432 }
4433
4434 rule__Property__Group__2__Impl
4435     @init {
4436                 int stackSize = keepStackSize();
4437     }
4438 :
4439 (
4440 { before(grammarAccess.getPropertyAccess().getGroup_2()); }
4441 (rule__Property__Group_2__0)*
4442 { after(grammarAccess.getPropertyAccess().getGroup_2()); }
4443 )
4444
4445 ;
4446 finally {
4447         restoreStackSize(stackSize);
4448 }
4449
4450
4451
4452
4453
4454
4455
4456
4457 rule__Property__Group_2__0
4458     @init {
4459                 int stackSize = keepStackSize();
4460     }
4461 :
4462         rule__Property__Group_2__0__Impl
4463         rule__Property__Group_2__1
4464 ;
4465 finally {
4466         restoreStackSize(stackSize);
4467 }
4468
4469 rule__Property__Group_2__0__Impl
4470     @init {
4471                 int stackSize = keepStackSize();
4472     }
4473 :
4474 (
4475 { before(grammarAccess.getPropertyAccess().getCommaKeyword_2_0()); }
4476
4477         ','
4478
4479 { after(grammarAccess.getPropertyAccess().getCommaKeyword_2_0()); }
4480 )
4481
4482 ;
4483 finally {
4484         restoreStackSize(stackSize);
4485 }
4486
4487
4488 rule__Property__Group_2__1
4489     @init {
4490                 int stackSize = keepStackSize();
4491     }
4492 :
4493         rule__Property__Group_2__1__Impl
4494 ;
4495 finally {
4496         restoreStackSize(stackSize);
4497 }
4498
4499 rule__Property__Group_2__1__Impl
4500     @init {
4501                 int stackSize = keepStackSize();
4502     }
4503 :
4504 (
4505 { before(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_2_1()); }
4506         ruleOneProperty
4507 { after(grammarAccess.getPropertyAccess().getOnePropertyParserRuleCall_2_1()); }
4508 )
4509
4510 ;
4511 finally {
4512         restoreStackSize(stackSize);
4513 }
4514
4515
4516
4517
4518
4519
4520 rule__OneProperty__Group__0
4521     @init {
4522                 int stackSize = keepStackSize();
4523     }
4524 :
4525         rule__OneProperty__Group__0__Impl
4526         rule__OneProperty__Group__1
4527 ;
4528 finally {
4529         restoreStackSize(stackSize);
4530 }
4531
4532 rule__OneProperty__Group__0__Impl
4533     @init {
4534                 int stackSize = keepStackSize();
4535     }
4536 :
4537 (
4538 { before(grammarAccess.getOnePropertyAccess().getNemoIdTerminalRuleCall_0()); }
4539         RULE_NEMOID
4540 { after(grammarAccess.getOnePropertyAccess().getNemoIdTerminalRuleCall_0()); }
4541 )
4542
4543 ;
4544 finally {
4545         restoreStackSize(stackSize);
4546 }
4547
4548
4549 rule__OneProperty__Group__1
4550     @init {
4551                 int stackSize = keepStackSize();
4552     }
4553 :
4554         rule__OneProperty__Group__1__Impl
4555         rule__OneProperty__Group__2
4556 ;
4557 finally {
4558         restoreStackSize(stackSize);
4559 }
4560
4561 rule__OneProperty__Group__1__Impl
4562     @init {
4563                 int stackSize = keepStackSize();
4564     }
4565 :
4566 (
4567 { before(grammarAccess.getOnePropertyAccess().getColonKeyword_1()); }
4568
4569         ':'
4570
4571 { after(grammarAccess.getOnePropertyAccess().getColonKeyword_1()); }
4572 )
4573
4574 ;
4575 finally {
4576         restoreStackSize(stackSize);
4577 }
4578
4579
4580 rule__OneProperty__Group__2
4581     @init {
4582                 int stackSize = keepStackSize();
4583     }
4584 :
4585         rule__OneProperty__Group__2__Impl
4586 ;
4587 finally {
4588         restoreStackSize(stackSize);
4589 }
4590
4591 rule__OneProperty__Group__2__Impl
4592     @init {
4593                 int stackSize = keepStackSize();
4594     }
4595 :
4596 (
4597 { before(grammarAccess.getOnePropertyAccess().getAlternatives_2()); }
4598 (rule__OneProperty__Alternatives_2)
4599 { after(grammarAccess.getOnePropertyAccess().getAlternatives_2()); }
4600 )
4601
4602 ;
4603 finally {
4604         restoreStackSize(stackSize);
4605 }
4606
4607
4608
4609
4610
4611
4612
4613
4614 rule__ModelProperty__Group__0
4615     @init {
4616                 int stackSize = keepStackSize();
4617     }
4618 :
4619         rule__ModelProperty__Group__0__Impl
4620         rule__ModelProperty__Group__1
4621 ;
4622 finally {
4623         restoreStackSize(stackSize);
4624 }
4625
4626 rule__ModelProperty__Group__0__Impl
4627     @init {
4628                 int stackSize = keepStackSize();
4629     }
4630 :
4631 (
4632 { before(grammarAccess.getModelPropertyAccess().getPropertyKeyword_0()); }
4633
4634         'Property'
4635
4636 { after(grammarAccess.getModelPropertyAccess().getPropertyKeyword_0()); }
4637 )
4638
4639 ;
4640 finally {
4641         restoreStackSize(stackSize);
4642 }
4643
4644
4645 rule__ModelProperty__Group__1
4646     @init {
4647                 int stackSize = keepStackSize();
4648     }
4649 :
4650         rule__ModelProperty__Group__1__Impl
4651         rule__ModelProperty__Group__2
4652 ;
4653 finally {
4654         restoreStackSize(stackSize);
4655 }
4656
4657 rule__ModelProperty__Group__1__Impl
4658     @init {
4659                 int stackSize = keepStackSize();
4660     }
4661 :
4662 (
4663 { before(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_1()); }
4664         ruleOneModelProperty
4665 { after(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_1()); }
4666 )
4667
4668 ;
4669 finally {
4670         restoreStackSize(stackSize);
4671 }
4672
4673
4674 rule__ModelProperty__Group__2
4675     @init {
4676                 int stackSize = keepStackSize();
4677     }
4678 :
4679         rule__ModelProperty__Group__2__Impl
4680 ;
4681 finally {
4682         restoreStackSize(stackSize);
4683 }
4684
4685 rule__ModelProperty__Group__2__Impl
4686     @init {
4687                 int stackSize = keepStackSize();
4688     }
4689 :
4690 (
4691 { before(grammarAccess.getModelPropertyAccess().getGroup_2()); }
4692 (rule__ModelProperty__Group_2__0)*
4693 { after(grammarAccess.getModelPropertyAccess().getGroup_2()); }
4694 )
4695
4696 ;
4697 finally {
4698         restoreStackSize(stackSize);
4699 }
4700
4701
4702
4703
4704
4705
4706
4707
4708 rule__ModelProperty__Group_2__0
4709     @init {
4710                 int stackSize = keepStackSize();
4711     }
4712 :
4713         rule__ModelProperty__Group_2__0__Impl
4714         rule__ModelProperty__Group_2__1
4715 ;
4716 finally {
4717         restoreStackSize(stackSize);
4718 }
4719
4720 rule__ModelProperty__Group_2__0__Impl
4721     @init {
4722                 int stackSize = keepStackSize();
4723     }
4724 :
4725 (
4726 { before(grammarAccess.getModelPropertyAccess().getCommaKeyword_2_0()); }
4727
4728         ','
4729
4730 { after(grammarAccess.getModelPropertyAccess().getCommaKeyword_2_0()); }
4731 )
4732
4733 ;
4734 finally {
4735         restoreStackSize(stackSize);
4736 }
4737
4738
4739 rule__ModelProperty__Group_2__1
4740     @init {
4741                 int stackSize = keepStackSize();
4742     }
4743 :
4744         rule__ModelProperty__Group_2__1__Impl
4745 ;
4746 finally {
4747         restoreStackSize(stackSize);
4748 }
4749
4750 rule__ModelProperty__Group_2__1__Impl
4751     @init {
4752                 int stackSize = keepStackSize();
4753     }
4754 :
4755 (
4756 { before(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_2_1()); }
4757         ruleOneModelProperty
4758 { after(grammarAccess.getModelPropertyAccess().getOneModelPropertyParserRuleCall_2_1()); }
4759 )
4760
4761 ;
4762 finally {
4763         restoreStackSize(stackSize);
4764 }
4765
4766
4767
4768
4769
4770
4771 rule__OneModelProperty__Group__0
4772     @init {
4773                 int stackSize = keepStackSize();
4774     }
4775 :
4776         rule__OneModelProperty__Group__0__Impl
4777         rule__OneModelProperty__Group__1
4778 ;
4779 finally {
4780         restoreStackSize(stackSize);
4781 }
4782
4783 rule__OneModelProperty__Group__0__Impl
4784     @init {
4785                 int stackSize = keepStackSize();
4786     }
4787 :
4788 (
4789 { before(grammarAccess.getOneModelPropertyAccess().getAlternatives_0()); }
4790 (rule__OneModelProperty__Alternatives_0)
4791 { after(grammarAccess.getOneModelPropertyAccess().getAlternatives_0()); }
4792 )
4793
4794 ;
4795 finally {
4796         restoreStackSize(stackSize);
4797 }
4798
4799
4800 rule__OneModelProperty__Group__1
4801     @init {
4802                 int stackSize = keepStackSize();
4803     }
4804 :
4805         rule__OneModelProperty__Group__1__Impl
4806         rule__OneModelProperty__Group__2
4807 ;
4808 finally {
4809         restoreStackSize(stackSize);
4810 }
4811
4812 rule__OneModelProperty__Group__1__Impl
4813     @init {
4814                 int stackSize = keepStackSize();
4815     }
4816 :
4817 (
4818 { before(grammarAccess.getOneModelPropertyAccess().getColonKeyword_1()); }
4819
4820         ':'
4821
4822 { after(grammarAccess.getOneModelPropertyAccess().getColonKeyword_1()); }
4823 )
4824
4825 ;
4826 finally {
4827         restoreStackSize(stackSize);
4828 }
4829
4830
4831 rule__OneModelProperty__Group__2
4832     @init {
4833                 int stackSize = keepStackSize();
4834     }
4835 :
4836         rule__OneModelProperty__Group__2__Impl
4837 ;
4838 finally {
4839         restoreStackSize(stackSize);
4840 }
4841
4842 rule__OneModelProperty__Group__2__Impl
4843     @init {
4844                 int stackSize = keepStackSize();
4845     }
4846 :
4847 (
4848 { before(grammarAccess.getOneModelPropertyAccess().getNemoIdTerminalRuleCall_2()); }
4849         RULE_NEMOID
4850 { after(grammarAccess.getOneModelPropertyAccess().getNemoIdTerminalRuleCall_2()); }
4851 )
4852
4853 ;
4854 finally {
4855         restoreStackSize(stackSize);
4856 }
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866 rule__Model__SentencesAssignment
4867     @init {
4868                 int stackSize = keepStackSize();
4869     }
4870 :
4871 (
4872 { before(grammarAccess.getModelAccess().getSentencesSentenceParserRuleCall_0()); }
4873         ruleSentence{ after(grammarAccess.getModelAccess().getSentencesSentenceParserRuleCall_0()); }
4874 )
4875
4876 ;
4877 finally {
4878         restoreStackSize(stackSize);
4879 }
4880
4881 rule__Node__NameAssignment_2
4882     @init {
4883                 int stackSize = keepStackSize();
4884     }
4885 :
4886 (
4887 { before(grammarAccess.getNodeAccess().getNameNemoIdTerminalRuleCall_2_0()); }
4888         RULE_NEMOID{ after(grammarAccess.getNodeAccess().getNameNemoIdTerminalRuleCall_2_0()); }
4889 )
4890
4891 ;
4892 finally {
4893         restoreStackSize(stackSize);
4894 }
4895
4896 rule__Node__NodesAssignment_4_1
4897     @init {
4898                 int stackSize = keepStackSize();
4899     }
4900 :
4901 (
4902 { before(grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_1_0()); }
4903 (
4904 { before(grammarAccess.getNodeAccess().getNodesNodeNemoIdTerminalRuleCall_4_1_0_1()); }
4905         RULE_NEMOID{ after(grammarAccess.getNodeAccess().getNodesNodeNemoIdTerminalRuleCall_4_1_0_1()); }
4906 )
4907 { after(grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_1_0()); }
4908 )
4909
4910 ;
4911 finally {
4912         restoreStackSize(stackSize);
4913 }
4914
4915 rule__Node__NodesAssignment_4_2_1
4916     @init {
4917                 int stackSize = keepStackSize();
4918     }
4919 :
4920 (
4921 { before(grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_2_1_0()); }
4922 (
4923 { before(grammarAccess.getNodeAccess().getNodesNodeNemoIdTerminalRuleCall_4_2_1_0_1()); }
4924         RULE_NEMOID{ after(grammarAccess.getNodeAccess().getNodesNodeNemoIdTerminalRuleCall_4_2_1_0_1()); }
4925 )
4926 { after(grammarAccess.getNodeAccess().getNodesNodeCrossReference_4_2_1_0()); }
4927 )
4928
4929 ;
4930 finally {
4931         restoreStackSize(stackSize);
4932 }
4933
4934
4935 rule__NodeOperating__NodenameAssignment_2
4936     @init {
4937                 int stackSize = keepStackSize();
4938     }
4939 :
4940 (
4941 { before(grammarAccess.getNodeOperatingAccess().getNodenameNodeCrossReference_2_0()); }
4942 (
4943 { before(grammarAccess.getNodeOperatingAccess().getNodenameNodeNemoIdTerminalRuleCall_2_0_1()); }
4944         RULE_NEMOID{ after(grammarAccess.getNodeOperatingAccess().getNodenameNodeNemoIdTerminalRuleCall_2_0_1()); }
4945 )
4946 { after(grammarAccess.getNodeOperatingAccess().getNodenameNodeCrossReference_2_0()); }
4947 )
4948
4949 ;
4950 finally {
4951         restoreStackSize(stackSize);
4952 }
4953
4954 rule__NodeOperating__NodesAssignment_4_1
4955     @init {
4956                 int stackSize = keepStackSize();
4957     }
4958 :
4959 (
4960 { before(grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_1_0()); }
4961 (
4962 { before(grammarAccess.getNodeOperatingAccess().getNodesNodeNemoIdTerminalRuleCall_4_1_0_1()); }
4963         RULE_NEMOID{ after(grammarAccess.getNodeOperatingAccess().getNodesNodeNemoIdTerminalRuleCall_4_1_0_1()); }
4964 )
4965 { after(grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_1_0()); }
4966 )
4967
4968 ;
4969 finally {
4970         restoreStackSize(stackSize);
4971 }
4972
4973 rule__NodeOperating__NodesAssignment_4_2_1
4974     @init {
4975                 int stackSize = keepStackSize();
4976     }
4977 :
4978 (
4979 { before(grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_2_1_0()); }
4980 (
4981 { before(grammarAccess.getNodeOperatingAccess().getNodesNodeNemoIdTerminalRuleCall_4_2_1_0_1()); }
4982         RULE_NEMOID{ after(grammarAccess.getNodeOperatingAccess().getNodesNodeNemoIdTerminalRuleCall_4_2_1_0_1()); }
4983 )
4984 { after(grammarAccess.getNodeOperatingAccess().getNodesNodeCrossReference_4_2_1_0()); }
4985 )
4986
4987 ;
4988 finally {
4989         restoreStackSize(stackSize);
4990 }
4991
4992 rule__Connection__NameAssignment_2
4993     @init {
4994                 int stackSize = keepStackSize();
4995     }
4996 :
4997 (
4998 { before(grammarAccess.getConnectionAccess().getNameNemoIdTerminalRuleCall_2_0()); }
4999         RULE_NEMOID{ after(grammarAccess.getConnectionAccess().getNameNemoIdTerminalRuleCall_2_0()); }
5000 )
5001
5002 ;
5003 finally {
5004         restoreStackSize(stackSize);
5005 }
5006
5007 rule__Connection__EndnodeAssignment_5_1
5008     @init {
5009                 int stackSize = keepStackSize();
5010     }
5011 :
5012 (
5013 { before(grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_1_0()); }
5014 (
5015 { before(grammarAccess.getConnectionAccess().getEndnodeNodeNemoIdTerminalRuleCall_5_1_0_1()); }
5016         RULE_NEMOID{ after(grammarAccess.getConnectionAccess().getEndnodeNodeNemoIdTerminalRuleCall_5_1_0_1()); }
5017 )
5018 { after(grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_1_0()); }
5019 )
5020
5021 ;
5022 finally {
5023         restoreStackSize(stackSize);
5024 }
5025
5026 rule__Connection__EndnodeAssignment_5_2_1
5027     @init {
5028                 int stackSize = keepStackSize();
5029     }
5030 :
5031 (
5032 { before(grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_2_1_0()); }
5033 (
5034 { before(grammarAccess.getConnectionAccess().getEndnodeNodeNemoIdTerminalRuleCall_5_2_1_0_1()); }
5035         RULE_NEMOID{ after(grammarAccess.getConnectionAccess().getEndnodeNodeNemoIdTerminalRuleCall_5_2_1_0_1()); }
5036 )
5037 { after(grammarAccess.getConnectionAccess().getEndnodeNodeCrossReference_5_2_1_0()); }
5038 )
5039
5040 ;
5041 finally {
5042         restoreStackSize(stackSize);
5043 }
5044
5045 rule__ConnectionUpdate__ConnectionnameAssignment_2
5046     @init {
5047                 int stackSize = keepStackSize();
5048     }
5049 :
5050 (
5051 { before(grammarAccess.getConnectionUpdateAccess().getConnectionnameConnectionCrossReference_2_0()); }
5052 (
5053 { before(grammarAccess.getConnectionUpdateAccess().getConnectionnameConnectionNemoIdTerminalRuleCall_2_0_1()); }
5054         RULE_NEMOID{ after(grammarAccess.getConnectionUpdateAccess().getConnectionnameConnectionNemoIdTerminalRuleCall_2_0_1()); }
5055 )
5056 { after(grammarAccess.getConnectionUpdateAccess().getConnectionnameConnectionCrossReference_2_0()); }
5057 )
5058
5059 ;
5060 finally {
5061         restoreStackSize(stackSize);
5062 }
5063
5064 rule__ConnectionUpdate__EndnodeAssignment_4_1
5065     @init {
5066                 int stackSize = keepStackSize();
5067     }
5068 :
5069 (
5070 { before(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_1_0()); }
5071 (
5072 { before(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeNemoIdTerminalRuleCall_4_1_0_1()); }
5073         RULE_NEMOID{ after(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeNemoIdTerminalRuleCall_4_1_0_1()); }
5074 )
5075 { after(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_1_0()); }
5076 )
5077
5078 ;
5079 finally {
5080         restoreStackSize(stackSize);
5081 }
5082
5083 rule__ConnectionUpdate__EndnodeAssignment_4_2_1
5084     @init {
5085                 int stackSize = keepStackSize();
5086     }
5087 :
5088 (
5089 { before(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_2_1_0()); }
5090 (
5091 { before(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeNemoIdTerminalRuleCall_4_2_1_0_1()); }
5092         RULE_NEMOID{ after(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeNemoIdTerminalRuleCall_4_2_1_0_1()); }
5093 )
5094 { after(grammarAccess.getConnectionUpdateAccess().getEndnodeNodeCrossReference_4_2_1_0()); }
5095 )
5096
5097 ;
5098 finally {
5099         restoreStackSize(stackSize);
5100 }
5101
5102 rule__Flow__NameAssignment_2
5103     @init {
5104                 int stackSize = keepStackSize();
5105     }
5106 :
5107 (
5108 { before(grammarAccess.getFlowAccess().getNameNemoIdTerminalRuleCall_2_0()); }
5109         RULE_NEMOID{ after(grammarAccess.getFlowAccess().getNameNemoIdTerminalRuleCall_2_0()); }
5110 )
5111
5112 ;
5113 finally {
5114         restoreStackSize(stackSize);
5115 }
5116
5117 rule__FlowUpdate__FlowIdAssignment_2
5118     @init {
5119                 int stackSize = keepStackSize();
5120     }
5121 :
5122 (
5123 { before(grammarAccess.getFlowUpdateAccess().getFlowIdFlowCrossReference_2_0()); }
5124 (
5125 { before(grammarAccess.getFlowUpdateAccess().getFlowIdFlowNemoIdTerminalRuleCall_2_0_1()); }
5126         RULE_NEMOID{ after(grammarAccess.getFlowUpdateAccess().getFlowIdFlowNemoIdTerminalRuleCall_2_0_1()); }
5127 )
5128 { after(grammarAccess.getFlowUpdateAccess().getFlowIdFlowCrossReference_2_0()); }
5129 )
5130
5131 ;
5132 finally {
5133         restoreStackSize(stackSize);
5134 }
5135
5136 rule__Operation__NameAssignment_2
5137     @init {
5138                 int stackSize = keepStackSize();
5139     }
5140 :
5141 (
5142 { before(grammarAccess.getOperationAccess().getNameNemoIdTerminalRuleCall_2_0()); }
5143         RULE_NEMOID{ after(grammarAccess.getOperationAccess().getNameNemoIdTerminalRuleCall_2_0()); }
5144 )
5145
5146 ;
5147 finally {
5148         restoreStackSize(stackSize);
5149 }
5150
5151 rule__Operation__ValueAssignment_3_1
5152     @init {
5153                 int stackSize = keepStackSize();
5154     }
5155 :
5156 (
5157 { before(grammarAccess.getOperationAccess().getValueINTTerminalRuleCall_3_1_0()); }
5158         RULE_INT{ after(grammarAccess.getOperationAccess().getValueINTTerminalRuleCall_3_1_0()); }
5159 )
5160
5161 ;
5162 finally {
5163         restoreStackSize(stackSize);
5164 }
5165
5166 rule__Operation__TargetIdAssignment_5
5167     @init {
5168                 int stackSize = keepStackSize();
5169     }
5170 :
5171 (
5172 { before(grammarAccess.getOperationAccess().getTargetIdFlowCrossReference_5_0()); }
5173 (
5174 { before(grammarAccess.getOperationAccess().getTargetIdFlowNemoIdTerminalRuleCall_5_0_1()); }
5175         RULE_NEMOID{ after(grammarAccess.getOperationAccess().getTargetIdFlowNemoIdTerminalRuleCall_5_0_1()); }
5176 )
5177 { after(grammarAccess.getOperationAccess().getTargetIdFlowCrossReference_5_0()); }
5178 )
5179
5180 ;
5181 finally {
5182         restoreStackSize(stackSize);
5183 }
5184
5185 rule__Operation__TargetNodeAssignment_8_1_2
5186     @init {
5187                 int stackSize = keepStackSize();
5188     }
5189 :
5190 (
5191 { before(grammarAccess.getOperationAccess().getTargetNodeNodeCrossReference_8_1_2_0()); }
5192 (
5193 { before(grammarAccess.getOperationAccess().getTargetNodeNodeNemoIdTerminalRuleCall_8_1_2_0_1()); }
5194         RULE_NEMOID{ after(grammarAccess.getOperationAccess().getTargetNodeNodeNemoIdTerminalRuleCall_8_1_2_0_1()); }
5195 )
5196 { after(grammarAccess.getOperationAccess().getTargetNodeNodeCrossReference_8_1_2_0()); }
5197 )
5198
5199 ;
5200 finally {
5201         restoreStackSize(stackSize);
5202 }
5203
5204
5205 RULE_IPV4_SUB : ('0'..'9'|'1'..'9' '0'..'9'|'1' '0'..'9' '0'..'9'|'2' '0'..'4' '0'..'9'|'25' '0'..'5');
5206
5207 RULE_NEMOID : ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'-'|'0'..'9')*;
5208
5209 RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
5210
5211 RULE_INT : ('0'..'9')+;
5212
5213 RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');
5214
5215 RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
5216
5217 RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
5218
5219 RULE_WS : (' '|'\t'|'\r'|'\n')+;
5220
5221 RULE_ANY_OTHER : .;
5222
5223