<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<component id="org.eclipse.ocl.xtext.oclstdlib" version="2">
    <resource path="src-gen/org/eclipse/ocl/examples/xtext/oclstdlib/parser/antlr/OCLstdlibParser.java" type="org.eclipse.ocl.xtext.oclstdlib.parser.antlr.OCLstdlibParser">
        <filter id="643842064">
            <message_arguments>
                <message_argument value="InternalOCLstdlibParser"/>
                <message_argument value="OCLstdlibParser"/>
                <message_argument value="createParser(XtextTokenStream)"/>
            </message_arguments>
        </filter>
    </resource>
    <resource path="src-gen/org/eclipse/ocl/examples/xtext/oclstdlib/serializer/AbstractOCLstdlibSyntacticSequencer.java" type="org.eclipse.ocl.xtext.oclstdlib.serializer.AbstractOCLstdlibSyntacticSequencer">
        <filter id="576720909">
            <message_arguments>
                <message_argument value="AbstractSyntacticSequencer"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="match_LibIterationCS_SemicolonKeyword_14_1_or___LeftCurlyBracketKeyword_14_0_0_RightCurlyBracketKeyword_14_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="match_LibOperationCS_SemicolonKeyword_13_1_or___LeftCurlyBracketKeyword_13_0_0_RightCurlyBracketKeyword_13_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="match_LibOperationCS_UnrestrictedNameParserRuleCall_13_0_1_1_1_q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="match_LibPackageCS___SemicolonKeyword_4_1_2_PrecedenceKeyword_4_1_0__q"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="match_LibPropertyCS_SemicolonKeyword_6_1_or___LeftCurlyBracketKeyword_6_0_0_RightCurlyBracketKeyword_6_0_2__"/>
            </message_arguments>
        </filter>
        <filter id="627060751">
            <message_arguments>
                <message_argument value="AbstractElementAlias"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <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="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="emit_LibIterationCS_SemicolonKeyword_14_1_or___LeftCurlyBracketKeyword_14_0_0_RightCurlyBracketKeyword_14_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="emit_LibOperationCS_SemicolonKeyword_13_1_or___LeftCurlyBracketKeyword_13_0_0_RightCurlyBracketKeyword_13_0_2__(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="emit_LibOperationCS_UnrestrictedNameParserRuleCall_13_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="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="emit_LibPackageCS___SemicolonKeyword_4_1_2_PrecedenceKeyword_4_1_0__q(EObject, ISyntacticSequencerPDAProviderISynNavigable, List&lt;INode&gt;)"/>
            </message_arguments>
        </filter>
        <filter id="643846161">
            <message_arguments>
                <message_argument value="ISynNavigable"/>
                <message_argument value="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="emit_LibPropertyCS_SemicolonKeyword_6_1_or___LeftCurlyBracketKeyword_6_0_0_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="AbstractOCLstdlibSyntacticSequencer"/>
                <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="AbstractOCLstdlibSyntacticSequencer"/>
                <message_argument value="emitUnassignedTokens(EObject, ISyntacticSequencerPDAProviderISynTransition, INode, INode)"/>
            </message_arguments>
        </filter>
    </resource>
    <resource path="src/org/eclipse/ocl/examples/xtext/oclstdlib/ResourceSetClasspathTypeProviderFactory.java" type="org.eclipse.ocl.xtext.oclstdlib.ResourceSetClasspathTypeProviderFactory">
        <filter id="643842064">
            <message_arguments>
                <message_argument value="ClasspathTypeProvider"/>
                <message_argument value="ResourceSetClasspathTypeProviderFactory"/>
                <message_argument value="createClasspathTypeProvider(ResourceSet)"/>
            </message_arguments>
        </filter>
    </resource>
</component>
