<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<component id="org.eclipse.ocl.xtext.oclinecore" version="2">
    <resource path="src-gen/org/eclipse/ocl/examples/xtext/oclinecore/parser/antlr/OCLinEcoreParser.java" type="org.eclipse.ocl.xtext.oclinecore.parser.antlr.OCLinEcoreParser">
        <filter id="643842064">
            <message_arguments>
                <message_argument value="InternalOCLinEcoreParser"/>
                <message_argument value="OCLinEcoreParser"/>
                <message_argument value="createParser(XtextTokenStream)"/>
            </message_arguments>
        </filter>
    </resource>
    <resource path="src-gen/org/eclipse/ocl/examples/xtext/oclinecore/serializer/AbstractOCLinEcoreSyntacticSequencer.java" type="org.eclipse.ocl.xtext.oclinecore.serializer.AbstractOCLinEcoreSyntacticSequencer">
        <filter id="576720909">
            <message_arguments>
                <message_argument value="AbstractSyntacticSequencer"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS_CommaKeyword_5_1_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS_SemicolonKeyword_6_1_or___LeftCurlyBracketKeyword_6_0_0_____DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4___or___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4____a_RightCurlyBracketKeyword_6_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS_UnrestrictedNameParserRuleCall_6_0_1_1_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS_UnrestrictedNameParserRuleCall_6_0_1_2_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a___or_____DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a_SemicolonKeyword_6_0_1_1_4__q___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__p_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a___SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__p_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a__a__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a___or_____InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a_SemicolonKeyword_6_0_1_2_4__q___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__p_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a___SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__p_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a__a__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__p"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS___SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__p"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_AttributeCS_____DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4___or___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4____a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ClassCS_SemicolonKeyword_7_1_or___LeftCurlyBracketKeyword_7_0_0_RightCurlyBracketKeyword_7_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_DataTypeCS_SemicolonKeyword_5_1_or___LeftCurlyBracketKeyword_5_0_0_RightCurlyBracketKeyword_5_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_DataTypeCS___LeftCurlyBracketKeyword_4_0_RightCurlyBracketKeyword_4_2__q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_EnumerationCS_SemicolonKeyword_5_1_or___LeftCurlyBracketKeyword_5_0_0_RightCurlyBracketKeyword_5_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_EnumerationCS___LeftCurlyBracketKeyword_4_0_RightCurlyBracketKeyword_4_2__q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_EnumerationLiteralCS_SemicolonKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_InvariantConstraintCS_SemicolonKeyword_3_1_or___ColonKeyword_3_0_0_SemicolonKeyword_3_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_OperationCS_CommaKeyword_9_1_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_OperationCS_SemicolonKeyword_10_1_or___LeftCurlyBracketKeyword_10_0_0___BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2_SemicolonKeyword_10_0_1_2_4__a_RightCurlyBracketKeyword_10_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_OperationCS_UnrestrictedNameParserRuleCall_10_0_1_2_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_OperationCS___BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2_SemicolonKeyword_10_0_1_2_4__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_OperationCS___SemicolonKeyword_10_0_1_2_4_BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_OperationCS___SemicolonKeyword_10_0_1_2_4_BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2__p"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_PackageCS_SemicolonKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ParameterCS_CommaKeyword_2_1_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ParameterCS___LeftCurlyBracketKeyword_3_0_RightCurlyBracketKeyword_3_2__q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS_CommaKeyword_6_1_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS_SemicolonKeyword_7_1_or___LeftCurlyBracketKeyword_7_0_0_____DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4___or___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4____a_RightCurlyBracketKeyword_7_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS_UnrestrictedNameParserRuleCall_7_0_1_2_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS_UnrestrictedNameParserRuleCall_7_0_1_3_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a___or_____DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a_SemicolonKeyword_7_0_1_2_4__q___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__p_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a___SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__p_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a__a__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a___or_____InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a_SemicolonKeyword_7_0_1_3_4__q___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__p_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a___SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__p_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a__a__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__p"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS___SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__p"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_ReferenceCS_____DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4___or___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4____a"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_TopLevelCS___ModuleKeyword_1_0_UnrestrictedNameParserRuleCall_1_1__q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="match_TupleTypeCS___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS_CommaKeyword_5_1_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS_SemicolonKeyword_6_1_or___LeftCurlyBracketKeyword_6_0_0_____DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4___or___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4____a_RightCurlyBracketKeyword_6_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS_UnrestrictedNameParserRuleCall_6_0_1_1_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS_UnrestrictedNameParserRuleCall_6_0_1_2_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a___or_____DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a_SemicolonKeyword_6_0_1_1_4__q___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__p_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a___SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__p_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2___SemicolonKeyword_6_0_1_1_4_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a__a__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a___or_____InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a_SemicolonKeyword_6_0_1_2_4__q___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__p_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a___SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__p_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2___SemicolonKeyword_6_0_1_2_4_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a__a__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___SemicolonKeyword_6_0_1_1_4___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4__a_DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2__p(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS___SemicolonKeyword_6_0_1_2_4___DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4__a_InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2__p(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_AttributeCS_____DerivationKeyword_6_0_1_1_0_UnrestrictedNameParserRuleCall_6_0_1_1_1_q_ColonKeyword_6_0_1_1_2_SemicolonKeyword_6_0_1_1_4___or___InitialKeyword_6_0_1_2_0_UnrestrictedNameParserRuleCall_6_0_1_2_1_q_ColonKeyword_6_0_1_2_2_SemicolonKeyword_6_0_1_2_4____a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ClassCS_SemicolonKeyword_7_1_or___LeftCurlyBracketKeyword_7_0_0_RightCurlyBracketKeyword_7_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_DataTypeCS_SemicolonKeyword_5_1_or___LeftCurlyBracketKeyword_5_0_0_RightCurlyBracketKeyword_5_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_DataTypeCS___LeftCurlyBracketKeyword_4_0_RightCurlyBracketKeyword_4_2__q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_EnumerationCS_SemicolonKeyword_5_1_or___LeftCurlyBracketKeyword_5_0_0_RightCurlyBracketKeyword_5_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_EnumerationCS___LeftCurlyBracketKeyword_4_0_RightCurlyBracketKeyword_4_2__q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_EnumerationLiteralCS_SemicolonKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_InvariantConstraintCS_SemicolonKeyword_3_1_or___ColonKeyword_3_0_0_SemicolonKeyword_3_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_OperationCS_CommaKeyword_9_1_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_OperationCS_SemicolonKeyword_10_1_or___LeftCurlyBracketKeyword_10_0_0___BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2_SemicolonKeyword_10_0_1_2_4__a_RightCurlyBracketKeyword_10_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_OperationCS_UnrestrictedNameParserRuleCall_10_0_1_2_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_OperationCS___BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2_SemicolonKeyword_10_0_1_2_4__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_OperationCS___SemicolonKeyword_10_0_1_2_4_BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_OperationCS___SemicolonKeyword_10_0_1_2_4_BodyKeyword_10_0_1_2_0_UnrestrictedNameParserRuleCall_10_0_1_2_1_q_ColonKeyword_10_0_1_2_2__p(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_PackageCS_SemicolonKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ParameterCS_CommaKeyword_2_1_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ParameterCS___LeftCurlyBracketKeyword_3_0_RightCurlyBracketKeyword_3_2__q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS_CommaKeyword_6_1_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS_SemicolonKeyword_7_1_or___LeftCurlyBracketKeyword_7_0_0_____DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4___or___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4____a_RightCurlyBracketKeyword_7_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS_UnrestrictedNameParserRuleCall_7_0_1_2_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS_UnrestrictedNameParserRuleCall_7_0_1_3_1_q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a___or_____DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a_SemicolonKeyword_7_0_1_2_4__q___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__p_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a___SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__p_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2___SemicolonKeyword_7_0_1_2_4_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a__a__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a___or_____InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a_SemicolonKeyword_7_0_1_3_4__q___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__p_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a___SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__p_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2___SemicolonKeyword_7_0_1_3_4_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a__a__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___SemicolonKeyword_7_0_1_2_4___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4__a_DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2__p(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS___SemicolonKeyword_7_0_1_3_4___DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4__a_InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2__p(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_ReferenceCS_____DerivationKeyword_7_0_1_2_0_UnrestrictedNameParserRuleCall_7_0_1_2_1_q_ColonKeyword_7_0_1_2_2_SemicolonKeyword_7_0_1_2_4___or___InitialKeyword_7_0_1_3_0_UnrestrictedNameParserRuleCall_7_0_1_3_1_q_ColonKeyword_7_0_1_3_2_SemicolonKeyword_7_0_1_3_4____a(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_TopLevelCS___ModuleKeyword_1_0_UnrestrictedNameParserRuleCall_1_1__q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emit_TupleTypeCS___LeftParenthesisKeyword_1_0_RightParenthesisKeyword_1_2__q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynTransition"/>
                <message_argument value="AbstractOCLinEcoreSyntacticSequencer"/>
                <message_argument value="emitUnassignedTokens(EObject, ISyntacticSequencerPDAProviderISynTransition, INode, INode)"/>
            </message_arguments>
        </filter>
    </resource>
</component>
