-- @atlcompiler atl2006
-- Generated by: $Id: EModelCopyGenerator.atl 7948 2010-01-31 11:48:43Z dwagelaa $
module EModelMerge;

create OUT : OUTMODEL from IN : INMODEL, MERGE : INMODEL;

helper def : inElements : Set(INMODEL!"ecore::EObject") = INMODEL!"ecore::EObject".allInstancesFrom('IN');

helper def : mergeElements : Set(INMODEL!"ecore::EObject") = INMODEL!"ecore::EObject".allInstancesFrom('MERGE');

helper context OclAny def : isInElement : Boolean =
	thisModule.inElements->includes(self);

helper context OclAny def : isMergeElement : Boolean =
	thisModule.mergeElements->includes(self);

rule Comment {
    from s : INMODEL!"uml::Comment",
         m : INMODEL!"uml::Comment" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Comment" (
        __xmiID__ <- s.__xmiID__,
        body <- s.body,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        annotatedElement <- s.annotatedElement)
}

rule Package {
    from s : INMODEL!"uml::Package",
         m : INMODEL!"uml::Package" (
		if s.oclIsTypeOf(INMODEL!"uml::Package") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Package") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Package" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        packageMerge <- s.packageMerge,
        packagedElement <- s.packagedElement,
        profileApplication <- s.profileApplication)
}

rule Dependency {
    from s : INMODEL!"uml::Dependency",
         m : INMODEL!"uml::Dependency" (
		if s.oclIsTypeOf(INMODEL!"uml::Dependency") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Dependency") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Dependency" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client)
}

rule ElementImport {
    from s : INMODEL!"uml::ElementImport",
         m : INMODEL!"uml::ElementImport" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ElementImport" (
        __xmiID__ <- s.__xmiID__,
        visibility <- s.visibility,
        alias <- s.alias,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        importedElement <- s.importedElement)
}

rule PackageImport {
    from s : INMODEL!"uml::PackageImport",
         m : INMODEL!"uml::PackageImport" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::PackageImport" (
        __xmiID__ <- s.__xmiID__,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        importedPackage <- s.importedPackage)
}

rule Constraint {
    from s : INMODEL!"uml::Constraint",
         m : INMODEL!"uml::Constraint" (
		if s.oclIsTypeOf(INMODEL!"uml::Constraint") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Constraint") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Constraint" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        constrainedElement <- s.constrainedElement,
        specification <- s.specification)
}

rule Association {
    from s : INMODEL!"uml::Association",
         m : INMODEL!"uml::Association" (
		if s.oclIsTypeOf(INMODEL!"uml::Association") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Association") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Association" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isDerived <- s.isDerived,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedEnd <- s.ownedEnd,
        memberEnd <- s.memberEnd,
        navigableOwnedEnd <- s.navigableOwnedEnd)
}

rule TemplateBinding {
    from s : INMODEL!"uml::TemplateBinding",
         m : INMODEL!"uml::TemplateBinding" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TemplateBinding" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        signature <- s.signature,
        parameterSubstitution <- s.parameterSubstitution)
}

rule TemplateSignature {
    from s : INMODEL!"uml::TemplateSignature",
         m : INMODEL!"uml::TemplateSignature" (
		if s.oclIsTypeOf(INMODEL!"uml::TemplateSignature") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::TemplateSignature") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::TemplateSignature" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        parameter <- s.parameter,
        ownedParameter <- s.ownedParameter)
}

rule TemplateParameter {
    from s : INMODEL!"uml::TemplateParameter",
         m : INMODEL!"uml::TemplateParameter" (
		if s.oclIsTypeOf(INMODEL!"uml::TemplateParameter") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::TemplateParameter") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::TemplateParameter" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        parameteredElement <- s.parameteredElement,
        ownedParameteredElement <- s.ownedParameteredElement,
        default <- s.default,
        ownedDefault <- s.ownedDefault)
}

rule TemplateParameterSubstitution {
    from s : INMODEL!"uml::TemplateParameterSubstitution",
         m : INMODEL!"uml::TemplateParameterSubstitution" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TemplateParameterSubstitution" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        formal <- s.formal,
        actual <- s.actual,
        ownedActual <- s.ownedActual)
}

rule Generalization {
    from s : INMODEL!"uml::Generalization",
         m : INMODEL!"uml::Generalization" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Generalization" (
        __xmiID__ <- s.__xmiID__,
        isSubstitutable <- s.isSubstitutable,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        general <- s.general,
        generalizationSet <- s.generalizationSet)
}

rule GeneralizationSet {
    from s : INMODEL!"uml::GeneralizationSet",
         m : INMODEL!"uml::GeneralizationSet" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::GeneralizationSet" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isCovering <- s.isCovering,
        isDisjoint <- s.isDisjoint,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        powertype <- s.powertype,
        generalization <- s.generalization)
}

rule Substitution {
    from s : INMODEL!"uml::Substitution",
         m : INMODEL!"uml::Substitution" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Substitution" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        mapping <- s.mapping,
        contract <- s.contract)
}

rule Realization {
    from s : INMODEL!"uml::Realization",
         m : INMODEL!"uml::Realization" (
		if s.oclIsTypeOf(INMODEL!"uml::Realization") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Realization") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Realization" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        mapping <- s.mapping)
}

rule Abstraction {
    from s : INMODEL!"uml::Abstraction",
         m : INMODEL!"uml::Abstraction" (
		if s.oclIsTypeOf(INMODEL!"uml::Abstraction") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Abstraction") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Abstraction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        mapping <- s.mapping)
}

rule OpaqueExpression {
    from s : INMODEL!"uml::OpaqueExpression",
         m : INMODEL!"uml::OpaqueExpression" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::OpaqueExpression" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        body <- s.body,
        language <- s.language,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        behavior <- s.behavior)
}

rule Parameter {
    from s : INMODEL!"uml::Parameter",
         m : INMODEL!"uml::Parameter" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Parameter" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        direction <- s.direction,
        isException <- s.isException,
        isStream <- s.isStream,
        effect <- s.effect,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        templateParameter <- s.templateParameter,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        parameterSet <- s.parameterSet,
        defaultValue <- s.defaultValue)
}

rule ConnectorEnd {
    from s : INMODEL!"uml::ConnectorEnd",
         m : INMODEL!"uml::ConnectorEnd" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ConnectorEnd" (
        __xmiID__ <- s.__xmiID__,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        role <- s.role,
        partWithPort <- s.partWithPort)
}

rule Property {
    from s : INMODEL!"uml::Property",
         m : INMODEL!"uml::Property" (
		if s.oclIsTypeOf(INMODEL!"uml::Property") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Property") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Property" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isStatic <- s.isStatic,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isReadOnly <- s.isReadOnly,
        isDerived <- s.isDerived,
        isDerivedUnion <- s.isDerivedUnion,
        aggregation <- s.aggregation,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        templateParameter <- s.templateParameter,
        deployment <- s.deployment,
        redefinedProperty <- s.redefinedProperty,
        defaultValue <- s.defaultValue,
        subsettedProperty <- s.subsettedProperty,
        association <- s.association,
        qualifier <- s.qualifier)
}

rule Deployment {
    from s : INMODEL!"uml::Deployment",
         m : INMODEL!"uml::Deployment" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Deployment" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        deployedArtifact <- s.deployedArtifact,
        configuration <- s.configuration)
}

rule DeploymentSpecification {
    from s : INMODEL!"uml::DeploymentSpecification",
         m : INMODEL!"uml::DeploymentSpecification" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DeploymentSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        fileName <- s.fileName,
        deploymentLocation <- s.deploymentLocation,
        executionLocation <- s.executionLocation,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        nestedArtifact <- s.nestedArtifact,
        manifestation <- s.manifestation,
        ownedOperation <- s.ownedOperation,
        ownedAttribute <- s.ownedAttribute)
}

rule Artifact {
    from s : INMODEL!"uml::Artifact",
         m : INMODEL!"uml::Artifact" (
		if s.oclIsTypeOf(INMODEL!"uml::Artifact") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Artifact") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Artifact" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        fileName <- s.fileName,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        nestedArtifact <- s.nestedArtifact,
        manifestation <- s.manifestation,
        ownedOperation <- s.ownedOperation,
        ownedAttribute <- s.ownedAttribute)
}

rule Manifestation {
    from s : INMODEL!"uml::Manifestation",
         m : INMODEL!"uml::Manifestation" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Manifestation" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        mapping <- s.mapping,
        utilizedElement <- s.utilizedElement)
}

rule Operation {
    from s : INMODEL!"uml::Operation",
         m : INMODEL!"uml::Operation" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Operation" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isStatic <- s.isStatic,
        isAbstract <- s.isAbstract,
        concurrency <- s.concurrency,
        isQuery <- s.isQuery,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        ownedParameter <- s.ownedParameter,
        method <- s.method,
        raisedException <- s.raisedException,
        ownedParameterSet <- s.ownedParameterSet,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        redefinedOperation <- s.redefinedOperation,
        bodyCondition <- s.bodyCondition)
}

rule Class {
    from s : INMODEL!"uml::Class",
         m : INMODEL!"uml::Class" (
		if s.oclIsTypeOf(INMODEL!"uml::Class") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Class") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Class" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception)
}

rule InterfaceRealization {
    from s : INMODEL!"uml::InterfaceRealization",
         m : INMODEL!"uml::InterfaceRealization" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InterfaceRealization" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        mapping <- s.mapping,
        contract <- s.contract)
}

rule Interface {
    from s : INMODEL!"uml::Interface",
         m : INMODEL!"uml::Interface" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Interface" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedOperation <- s.ownedOperation,
        nestedClassifier <- s.nestedClassifier,
        redefinedInterface <- s.redefinedInterface,
        ownedReception <- s.ownedReception,
        protocol <- s.protocol)
}

rule Reception {
    from s : INMODEL!"uml::Reception",
         m : INMODEL!"uml::Reception" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Reception" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isStatic <- s.isStatic,
        isAbstract <- s.isAbstract,
        concurrency <- s.concurrency,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        ownedParameter <- s.ownedParameter,
        method <- s.method,
        raisedException <- s.raisedException,
        ownedParameterSet <- s.ownedParameterSet,
        signal <- s.signal)
}

rule Signal {
    from s : INMODEL!"uml::Signal",
         m : INMODEL!"uml::Signal" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Signal" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute)
}

rule ProtocolStateMachine {
    from s : INMODEL!"uml::ProtocolStateMachine",
         m : INMODEL!"uml::ProtocolStateMachine" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ProtocolStateMachine" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isReentrant <- s.isReentrant,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        redefinedBehavior <- s.redefinedBehavior,
        ownedParameter <- s.ownedParameter,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        ownedParameterSet <- s.ownedParameterSet,
        specification <- s.specification,
        region <- s.region,
        submachineState <- s.submachineState,
        connectionPoint <- s.connectionPoint,
        extendedStateMachine <- s.extendedStateMachine,
        conformance <- s.conformance)
}

rule StateMachine {
    from s : INMODEL!"uml::StateMachine",
         m : INMODEL!"uml::StateMachine" (
		if s.oclIsTypeOf(INMODEL!"uml::StateMachine") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::StateMachine") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::StateMachine" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isReentrant <- s.isReentrant,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        redefinedBehavior <- s.redefinedBehavior,
        ownedParameter <- s.ownedParameter,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        ownedParameterSet <- s.ownedParameterSet,
        specification <- s.specification,
        region <- s.region,
        submachineState <- s.submachineState,
        connectionPoint <- s.connectionPoint,
        extendedStateMachine <- s.extendedStateMachine)
}

rule Region {
    from s : INMODEL!"uml::Region",
         m : INMODEL!"uml::Region" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Region" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        subvertex <- s.subvertex,
        transition <- s.transition,
        extendedRegion <- s.extendedRegion)
}

rule Transition {
    from s : INMODEL!"uml::Transition",
         m : INMODEL!"uml::Transition" (
		if s.oclIsTypeOf(INMODEL!"uml::Transition") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Transition") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Transition" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        kind <- s.kind,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        source <- s.source,
        target <- s.target,
        redefinedTransition <- s.redefinedTransition,
        guard <- s.guard,
        effect <- s.effect,
        trigger <- s.trigger)
}

rule Trigger {
    from s : INMODEL!"uml::Trigger",
         m : INMODEL!"uml::Trigger" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Trigger" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        event <- s.event,
        port <- s.port)
}

rule Port {
    from s : INMODEL!"uml::Port",
         m : INMODEL!"uml::Port" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Port" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isStatic <- s.isStatic,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isReadOnly <- s.isReadOnly,
        isDerived <- s.isDerived,
        isDerivedUnion <- s.isDerivedUnion,
        aggregation <- s.aggregation,
        isBehavior <- s.isBehavior,
        isService <- s.isService,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        templateParameter <- s.templateParameter,
        deployment <- s.deployment,
        redefinedProperty <- s.redefinedProperty,
        defaultValue <- s.defaultValue,
        subsettedProperty <- s.subsettedProperty,
        association <- s.association,
        qualifier <- s.qualifier,
        redefinedPort <- s.redefinedPort,
        protocol <- s.protocol)
}

rule State {
    from s : INMODEL!"uml::State",
         m : INMODEL!"uml::State" (
		if s.oclIsTypeOf(INMODEL!"uml::State") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::State") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::State" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        submachine <- s.submachine,
        connection <- s.connection,
        connectionPoint <- s.connectionPoint,
        redefinedState <- s.redefinedState,
        stateInvariant <- s.stateInvariant,
        entry <- s.entry,
        exit <- s.exit,
        doActivity <- s.doActivity,
        deferrableTrigger <- s.deferrableTrigger,
        region <- s.region)
}

rule ConnectionPointReference {
    from s : INMODEL!"uml::ConnectionPointReference",
         m : INMODEL!"uml::ConnectionPointReference" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ConnectionPointReference" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        entry <- s.entry,
        exit <- s.exit)
}

rule Pseudostate {
    from s : INMODEL!"uml::Pseudostate",
         m : INMODEL!"uml::Pseudostate" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Pseudostate" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        kind <- s.kind,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression)
}

rule ProtocolConformance {
    from s : INMODEL!"uml::ProtocolConformance",
         m : INMODEL!"uml::ProtocolConformance" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ProtocolConformance" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        generalMachine <- s.generalMachine)
}

rule Connector {
    from s : INMODEL!"uml::Connector",
         m : INMODEL!"uml::Connector" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Connector" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isStatic <- s.isStatic,
        kind <- s.kind,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        redefinedConnector <- s.redefinedConnector,
        end <- s.end,
        contract <- s.contract)
}

rule Extension {
    from s : INMODEL!"uml::Extension",
         m : INMODEL!"uml::Extension" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Extension" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isDerived <- s.isDerived,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedEnd <- s.ownedEnd,
        memberEnd <- s.memberEnd,
        navigableOwnedEnd <- s.navigableOwnedEnd)
}

rule ExtensionEnd {
    from s : INMODEL!"uml::ExtensionEnd",
         m : INMODEL!"uml::ExtensionEnd" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExtensionEnd" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isStatic <- s.isStatic,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isReadOnly <- s.isReadOnly,
        isDerived <- s.isDerived,
        isDerivedUnion <- s.isDerivedUnion,
        aggregation <- s.aggregation,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        templateParameter <- s.templateParameter,
        deployment <- s.deployment,
        redefinedProperty <- s.redefinedProperty,
        defaultValue <- s.defaultValue,
        subsettedProperty <- s.subsettedProperty,
        association <- s.association,
        qualifier <- s.qualifier)
}

rule Image {
    from s : INMODEL!"uml::Image",
         m : INMODEL!"uml::Image" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Image" (
        __xmiID__ <- s.__xmiID__,
        content <- s.content,
        location <- s.location,
        format <- s.format,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment)
}

rule Model {
    from s : INMODEL!"uml::Model",
         m : INMODEL!"uml::Model" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Model" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        viewpoint <- s.viewpoint,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        packageMerge <- s.packageMerge,
        packagedElement <- s.packagedElement,
        profileApplication <- s.profileApplication)
}

rule ParameterSet {
    from s : INMODEL!"uml::ParameterSet",
         m : INMODEL!"uml::ParameterSet" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ParameterSet" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        parameter <- s.parameter,
        condition <- s.condition)
}

rule DataType {
    from s : INMODEL!"uml::DataType",
         m : INMODEL!"uml::DataType" (
		if s.oclIsTypeOf(INMODEL!"uml::DataType") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::DataType") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::DataType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedOperation <- s.ownedOperation)
}

rule OperationTemplateParameter {
    from s : INMODEL!"uml::OperationTemplateParameter",
         m : INMODEL!"uml::OperationTemplateParameter" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::OperationTemplateParameter" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        parameteredElement <- s.parameteredElement,
        ownedParameteredElement <- s.ownedParameteredElement,
        default <- s.default,
        ownedDefault <- s.ownedDefault)
}

rule ConnectableElementTemplateParameter {
    from s : INMODEL!"uml::ConnectableElementTemplateParameter",
         m : INMODEL!"uml::ConnectableElementTemplateParameter" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ConnectableElementTemplateParameter" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        parameteredElement <- s.parameteredElement,
        ownedParameteredElement <- s.ownedParameteredElement,
        default <- s.default,
        ownedDefault <- s.ownedDefault)
}

rule CollaborationUse {
    from s : INMODEL!"uml::CollaborationUse",
         m : INMODEL!"uml::CollaborationUse" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CollaborationUse" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        roleBinding <- s.roleBinding)
}

rule Collaboration {
    from s : INMODEL!"uml::Collaboration",
         m : INMODEL!"uml::Collaboration" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Collaboration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        collaborationRole <- s.collaborationRole)
}

rule UseCase {
    from s : INMODEL!"uml::UseCase",
         m : INMODEL!"uml::UseCase" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::UseCase" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        include <- s.include,
        extend <- s.extend,
        extensionPoint <- s.extensionPoint,
        subject <- s.subject)
}

rule Include {
    from s : INMODEL!"uml::Include",
         m : INMODEL!"uml::Include" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Include" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        addition <- s.addition)
}

rule Extend {
    from s : INMODEL!"uml::Extend",
         m : INMODEL!"uml::Extend" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Extend" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        extendedCase <- s.extendedCase,
        condition <- s.condition,
        extensionLocation <- s.extensionLocation)
}

rule ExtensionPoint {
    from s : INMODEL!"uml::ExtensionPoint",
         m : INMODEL!"uml::ExtensionPoint" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExtensionPoint" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression)
}

rule RedefinableTemplateSignature {
    from s : INMODEL!"uml::RedefinableTemplateSignature",
         m : INMODEL!"uml::RedefinableTemplateSignature" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::RedefinableTemplateSignature" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        parameter <- s.parameter,
        ownedParameter <- s.ownedParameter,
        extendedSignature <- s.extendedSignature)
}

rule ClassifierTemplateParameter {
    from s : INMODEL!"uml::ClassifierTemplateParameter",
         m : INMODEL!"uml::ClassifierTemplateParameter" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ClassifierTemplateParameter" (
        __xmiID__ <- s.__xmiID__,
        allowSubstitutable <- s.allowSubstitutable,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        parameteredElement <- s.parameteredElement,
        ownedParameteredElement <- s.ownedParameteredElement,
        default <- s.default,
        ownedDefault <- s.ownedDefault,
        constrainingClassifier <- s.constrainingClassifier)
}

rule StringExpression {
    from s : INMODEL!"uml::StringExpression",
         m : INMODEL!"uml::StringExpression" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::StringExpression" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        symbol <- s.symbol,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        operand <- s.operand,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        subExpression <- s.subExpression)
}

rule Expression {
    from s : INMODEL!"uml::Expression",
         m : INMODEL!"uml::Expression" (
		if s.oclIsTypeOf(INMODEL!"uml::Expression") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Expression") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Expression" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        symbol <- s.symbol,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        operand <- s.operand)
}

rule Usage {
    from s : INMODEL!"uml::Usage",
         m : INMODEL!"uml::Usage" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Usage" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client)
}

rule PackageMerge {
    from s : INMODEL!"uml::PackageMerge",
         m : INMODEL!"uml::PackageMerge" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::PackageMerge" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        mergedPackage <- s.mergedPackage)
}

rule ProfileApplication {
    from s : INMODEL!"uml::ProfileApplication",
         m : INMODEL!"uml::ProfileApplication" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ProfileApplication" (
        __xmiID__ <- s.__xmiID__,
        isStrict <- s.isStrict,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        appliedProfile <- s.appliedProfile)
}

rule Enumeration {
    from s : INMODEL!"uml::Enumeration",
         m : INMODEL!"uml::Enumeration" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Enumeration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedOperation <- s.ownedOperation,
        ownedLiteral <- s.ownedLiteral)
}

rule EnumerationLiteral {
    from s : INMODEL!"uml::EnumerationLiteral",
         m : INMODEL!"uml::EnumerationLiteral" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::EnumerationLiteral" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        deployment <- s.deployment,
        templateParameter <- s.templateParameter,
        classifier <- s.classifier,
        slot <- s.slot,
        specification <- s.specification)
}

rule InstanceSpecification {
    from s : INMODEL!"uml::InstanceSpecification",
         m : INMODEL!"uml::InstanceSpecification" (
		if s.oclIsTypeOf(INMODEL!"uml::InstanceSpecification") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::InstanceSpecification") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::InstanceSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        deployment <- s.deployment,
        templateParameter <- s.templateParameter,
        classifier <- s.classifier,
        slot <- s.slot,
        specification <- s.specification)
}

rule Slot {
    from s : INMODEL!"uml::Slot",
         m : INMODEL!"uml::Slot" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Slot" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        definingFeature <- s.definingFeature,
        value <- s.value)
}

rule PrimitiveType {
    from s : INMODEL!"uml::PrimitiveType",
         m : INMODEL!"uml::PrimitiveType" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::PrimitiveType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedOperation <- s.ownedOperation)
}

rule LiteralInteger {
    from s : INMODEL!"uml::LiteralInteger",
         m : INMODEL!"uml::LiteralInteger" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LiteralInteger" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        value <- s.value,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type)
}

rule LiteralString {
    from s : INMODEL!"uml::LiteralString",
         m : INMODEL!"uml::LiteralString" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LiteralString" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        value <- s.value,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type)
}

rule LiteralBoolean {
    from s : INMODEL!"uml::LiteralBoolean",
         m : INMODEL!"uml::LiteralBoolean" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LiteralBoolean" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        value <- s.value,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type)
}

rule LiteralNull {
    from s : INMODEL!"uml::LiteralNull",
         m : INMODEL!"uml::LiteralNull" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LiteralNull" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type)
}

rule InstanceValue {
    from s : INMODEL!"uml::InstanceValue",
         m : INMODEL!"uml::InstanceValue" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InstanceValue" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        instance <- s.instance)
}

rule LiteralUnlimitedNatural {
    from s : INMODEL!"uml::LiteralUnlimitedNatural",
         m : INMODEL!"uml::LiteralUnlimitedNatural" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LiteralUnlimitedNatural" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        value <- s.value,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type)
}

rule OpaqueBehavior {
    from s : INMODEL!"uml::OpaqueBehavior",
         m : INMODEL!"uml::OpaqueBehavior" (
		if s.oclIsTypeOf(INMODEL!"uml::OpaqueBehavior") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::OpaqueBehavior") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::OpaqueBehavior" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isReentrant <- s.isReentrant,
        body <- s.body,
        language <- s.language,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        redefinedBehavior <- s.redefinedBehavior,
        ownedParameter <- s.ownedParameter,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        ownedParameterSet <- s.ownedParameterSet,
        specification <- s.specification)
}

rule FunctionBehavior {
    from s : INMODEL!"uml::FunctionBehavior",
         m : INMODEL!"uml::FunctionBehavior" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::FunctionBehavior" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isReentrant <- s.isReentrant,
        body <- s.body,
        language <- s.language,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        redefinedBehavior <- s.redefinedBehavior,
        ownedParameter <- s.ownedParameter,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        ownedParameterSet <- s.ownedParameterSet,
        specification <- s.specification)
}

rule OpaqueAction {
    from s : INMODEL!"uml::OpaqueAction",
         m : INMODEL!"uml::OpaqueAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::OpaqueAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        body <- s.body,
        language <- s.language,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        inputValue <- s.inputValue,
        outputValue <- s.outputValue)
}

rule StructuredActivityNode {
    from s : INMODEL!"uml::StructuredActivityNode",
         m : INMODEL!"uml::StructuredActivityNode" (
		if s.oclIsTypeOf(INMODEL!"uml::StructuredActivityNode") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::StructuredActivityNode") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::StructuredActivityNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        mustIsolate <- s.mustIsolate,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        variable <- s.variable,
        edge <- s.edge,
        node <- s.node)
}

rule Activity {
    from s : INMODEL!"uml::Activity",
         m : INMODEL!"uml::Activity" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Activity" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isReentrant <- s.isReentrant,
        isReadOnly <- s.isReadOnly,
        isSingleExecution <- s.isSingleExecution,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        redefinedBehavior <- s.redefinedBehavior,
        ownedParameter <- s.ownedParameter,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        ownedParameterSet <- s.ownedParameterSet,
        specification <- s.specification,
        variable <- s.variable,
        node <- s.node,
        edge <- s.edge,
        partition <- s.partition,
        group <- s.group)
}

rule Variable {
    from s : INMODEL!"uml::Variable",
         m : INMODEL!"uml::Variable" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Variable" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        type <- s.type,
        templateParameter <- s.templateParameter,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue)
}

rule ActivityPartition {
    from s : INMODEL!"uml::ActivityPartition",
         m : INMODEL!"uml::ActivityPartition" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ActivityPartition" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isDimension <- s.isDimension,
        isExternal <- s.isExternal,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        node <- s.node,
        subpartition <- s.subpartition,
        represents <- s.represents,
        edge <- s.edge)
}

rule InterruptibleActivityRegion {
    from s : INMODEL!"uml::InterruptibleActivityRegion",
         m : INMODEL!"uml::InterruptibleActivityRegion" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InterruptibleActivityRegion" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        node <- s.node,
        interruptingEdge <- s.interruptingEdge)
}

rule ExceptionHandler {
    from s : INMODEL!"uml::ExceptionHandler",
         m : INMODEL!"uml::ExceptionHandler" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExceptionHandler" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        handlerBody <- s.handlerBody,
        exceptionInput <- s.exceptionInput,
        exceptionType <- s.exceptionType)
}

rule OutputPin {
    from s : INMODEL!"uml::OutputPin",
         m : INMODEL!"uml::OutputPin" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::OutputPin" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isControl <- s.isControl,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue)
}

rule Pin {
    from s : INMODEL!"uml::Pin",
         m : INMODEL!"uml::Pin" (
		if s.oclIsTypeOf(INMODEL!"uml::Pin") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Pin") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Pin" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isControl <- s.isControl,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue)
}

rule InputPin {
    from s : INMODEL!"uml::InputPin",
         m : INMODEL!"uml::InputPin" (
		if s.oclIsTypeOf(INMODEL!"uml::InputPin") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::InputPin") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::InputPin" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isControl <- s.isControl,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue)
}

rule SendSignalAction {
    from s : INMODEL!"uml::SendSignalAction",
         m : INMODEL!"uml::SendSignalAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::SendSignalAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        argument <- s.argument,
        onPort <- s.onPort,
        target <- s.target,
        signal <- s.signal)
}

rule CallOperationAction {
    from s : INMODEL!"uml::CallOperationAction",
         m : INMODEL!"uml::CallOperationAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CallOperationAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isSynchronous <- s.isSynchronous,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        argument <- s.argument,
        onPort <- s.onPort,
        result <- s.result,
        operation <- s.operation,
        target <- s.target)
}

rule CallBehaviorAction {
    from s : INMODEL!"uml::CallBehaviorAction",
         m : INMODEL!"uml::CallBehaviorAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CallBehaviorAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isSynchronous <- s.isSynchronous,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        argument <- s.argument,
        onPort <- s.onPort,
        result <- s.result,
        behavior <- s.behavior)
}

rule SequenceNode {
    from s : INMODEL!"uml::SequenceNode",
         m : INMODEL!"uml::SequenceNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::SequenceNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        mustIsolate <- s.mustIsolate,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        variable <- s.variable,
        edge <- s.edge,
        node <- s.node,
        executableNode <- s.executableNode)
}

rule ControlFlow {
    from s : INMODEL!"uml::ControlFlow",
         m : INMODEL!"uml::ControlFlow" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ControlFlow" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        source <- s.source,
        target <- s.target,
        redefinedEdge <- s.redefinedEdge,
        inPartition <- s.inPartition,
        guard <- s.guard,
        weight <- s.weight,
        interrupts <- s.interrupts)
}

rule InitialNode {
    from s : INMODEL!"uml::InitialNode",
         m : INMODEL!"uml::InitialNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InitialNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode)
}

rule ActivityParameterNode {
    from s : INMODEL!"uml::ActivityParameterNode",
         m : INMODEL!"uml::ActivityParameterNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ActivityParameterNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        parameter <- s.parameter)
}

rule ValuePin {
    from s : INMODEL!"uml::ValuePin",
         m : INMODEL!"uml::ValuePin" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ValuePin" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isControl <- s.isControl,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        value <- s.value)
}

rule Message {
    from s : INMODEL!"uml::Message",
         m : INMODEL!"uml::Message" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Message" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        messageSort <- s.messageSort,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        receiveEvent <- s.receiveEvent,
        sendEvent <- s.sendEvent,
        connector <- s.connector,
        argument <- s.argument)
}

rule Interaction {
    from s : INMODEL!"uml::Interaction",
         m : INMODEL!"uml::Interaction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Interaction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isReentrant <- s.isReentrant,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        redefinedBehavior <- s.redefinedBehavior,
        ownedParameter <- s.ownedParameter,
        precondition <- s.precondition,
        postcondition <- s.postcondition,
        ownedParameterSet <- s.ownedParameterSet,
        specification <- s.specification,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        lifeline <- s.lifeline,
        fragment <- s.fragment,
        action <- s.action,
        formalGate <- s.formalGate,
        message <- s.message)
}

rule Lifeline {
    from s : INMODEL!"uml::Lifeline",
         m : INMODEL!"uml::Lifeline" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Lifeline" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        represents <- s.represents,
        selector <- s.selector,
        decomposedAs <- s.decomposedAs,
        coveredBy <- s.coveredBy)
}

rule PartDecomposition {
    from s : INMODEL!"uml::PartDecomposition",
         m : INMODEL!"uml::PartDecomposition" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::PartDecomposition" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        refersTo <- s.refersTo,
        actualGate <- s.actualGate,
        argument <- s.argument)
}

rule InteractionUse {
    from s : INMODEL!"uml::InteractionUse",
         m : INMODEL!"uml::InteractionUse" (
		if s.oclIsTypeOf(INMODEL!"uml::InteractionUse") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::InteractionUse") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::InteractionUse" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        refersTo <- s.refersTo,
        actualGate <- s.actualGate,
        argument <- s.argument)
}

rule Gate {
    from s : INMODEL!"uml::Gate",
         m : INMODEL!"uml::Gate" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Gate" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        message <- s.message)
}

rule GeneralOrdering {
    from s : INMODEL!"uml::GeneralOrdering",
         m : INMODEL!"uml::GeneralOrdering" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::GeneralOrdering" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        before <- s.before,
        after <- s.after)
}

rule OccurrenceSpecification {
    from s : INMODEL!"uml::OccurrenceSpecification",
         m : INMODEL!"uml::OccurrenceSpecification" (
		if s.oclIsTypeOf(INMODEL!"uml::OccurrenceSpecification") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::OccurrenceSpecification") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::OccurrenceSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        toBefore <- s.toBefore,
        event <- s.event,
        toAfter <- s.toAfter)
}

rule InteractionOperand {
    from s : INMODEL!"uml::InteractionOperand",
         m : INMODEL!"uml::InteractionOperand" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InteractionOperand" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        guard <- s.guard,
        fragment <- s.fragment)
}

rule InteractionConstraint {
    from s : INMODEL!"uml::InteractionConstraint",
         m : INMODEL!"uml::InteractionConstraint" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InteractionConstraint" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        constrainedElement <- s.constrainedElement,
        specification <- s.specification,
        minint <- s.minint,
        maxint <- s.maxint)
}

rule StateInvariant {
    from s : INMODEL!"uml::StateInvariant",
         m : INMODEL!"uml::StateInvariant" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::StateInvariant" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        invariant <- s.invariant)
}

rule ActionExecutionSpecification {
    from s : INMODEL!"uml::ActionExecutionSpecification",
         m : INMODEL!"uml::ActionExecutionSpecification" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ActionExecutionSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        start <- s.start,
        finish <- s.finish,
        action <- s.action)
}

rule BehaviorExecutionSpecification {
    from s : INMODEL!"uml::BehaviorExecutionSpecification",
         m : INMODEL!"uml::BehaviorExecutionSpecification" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::BehaviorExecutionSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        start <- s.start,
        finish <- s.finish,
        behavior <- s.behavior)
}

rule ExecutionEvent {
    from s : INMODEL!"uml::ExecutionEvent",
         m : INMODEL!"uml::ExecutionEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExecutionEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter)
}

rule CreationEvent {
    from s : INMODEL!"uml::CreationEvent",
         m : INMODEL!"uml::CreationEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CreationEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter)
}

rule DestructionEvent {
    from s : INMODEL!"uml::DestructionEvent",
         m : INMODEL!"uml::DestructionEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DestructionEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter)
}

rule SendOperationEvent {
    from s : INMODEL!"uml::SendOperationEvent",
         m : INMODEL!"uml::SendOperationEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::SendOperationEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        operation <- s.operation)
}

rule SendSignalEvent {
    from s : INMODEL!"uml::SendSignalEvent",
         m : INMODEL!"uml::SendSignalEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::SendSignalEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        signal <- s.signal)
}

rule MessageOccurrenceSpecification {
    from s : INMODEL!"uml::MessageOccurrenceSpecification",
         m : INMODEL!"uml::MessageOccurrenceSpecification" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::MessageOccurrenceSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        toBefore <- s.toBefore,
        event <- s.event,
        toAfter <- s.toAfter,
        message <- s.message)
}

rule ExecutionOccurrenceSpecification {
    from s : INMODEL!"uml::ExecutionOccurrenceSpecification",
         m : INMODEL!"uml::ExecutionOccurrenceSpecification" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExecutionOccurrenceSpecification" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        toBefore <- s.toBefore,
        event <- s.event,
        toAfter <- s.toAfter,
        execution <- s.execution)
}

rule ReceiveOperationEvent {
    from s : INMODEL!"uml::ReceiveOperationEvent",
         m : INMODEL!"uml::ReceiveOperationEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReceiveOperationEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        operation <- s.operation)
}

rule ReceiveSignalEvent {
    from s : INMODEL!"uml::ReceiveSignalEvent",
         m : INMODEL!"uml::ReceiveSignalEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReceiveSignalEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        signal <- s.signal)
}

rule Actor {
    from s : INMODEL!"uml::Actor",
         m : INMODEL!"uml::Actor" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Actor" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger)
}

rule CallEvent {
    from s : INMODEL!"uml::CallEvent",
         m : INMODEL!"uml::CallEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CallEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        operation <- s.operation)
}

rule ChangeEvent {
    from s : INMODEL!"uml::ChangeEvent",
         m : INMODEL!"uml::ChangeEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ChangeEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        changeExpression <- s.changeExpression)
}

rule SignalEvent {
    from s : INMODEL!"uml::SignalEvent",
         m : INMODEL!"uml::SignalEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::SignalEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        signal <- s.signal)
}

rule AnyReceiveEvent {
    from s : INMODEL!"uml::AnyReceiveEvent",
         m : INMODEL!"uml::AnyReceiveEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::AnyReceiveEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter)
}

rule ForkNode {
    from s : INMODEL!"uml::ForkNode",
         m : INMODEL!"uml::ForkNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ForkNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode)
}

rule FlowFinalNode {
    from s : INMODEL!"uml::FlowFinalNode",
         m : INMODEL!"uml::FlowFinalNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::FlowFinalNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode)
}

rule CentralBufferNode {
    from s : INMODEL!"uml::CentralBufferNode",
         m : INMODEL!"uml::CentralBufferNode" (
		if s.oclIsTypeOf(INMODEL!"uml::CentralBufferNode") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::CentralBufferNode") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::CentralBufferNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection)
}

rule MergeNode {
    from s : INMODEL!"uml::MergeNode",
         m : INMODEL!"uml::MergeNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::MergeNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode)
}

rule DecisionNode {
    from s : INMODEL!"uml::DecisionNode",
         m : INMODEL!"uml::DecisionNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DecisionNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        decisionInput <- s.decisionInput,
        decisionInputFlow <- s.decisionInputFlow)
}

rule ObjectFlow {
    from s : INMODEL!"uml::ObjectFlow",
         m : INMODEL!"uml::ObjectFlow" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ObjectFlow" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isMulticast <- s.isMulticast,
        isMultireceive <- s.isMultireceive,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        source <- s.source,
        target <- s.target,
        redefinedEdge <- s.redefinedEdge,
        inPartition <- s.inPartition,
        guard <- s.guard,
        weight <- s.weight,
        interrupts <- s.interrupts,
        transformation <- s.transformation,
        selection <- s.selection)
}

rule ActivityFinalNode {
    from s : INMODEL!"uml::ActivityFinalNode",
         m : INMODEL!"uml::ActivityFinalNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ActivityFinalNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode)
}

rule ComponentRealization {
    from s : INMODEL!"uml::ComponentRealization",
         m : INMODEL!"uml::ComponentRealization" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ComponentRealization" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        supplier <- s.supplier,
        client <- s.client,
        mapping <- s.mapping,
        realizingClassifier <- s.realizingClassifier)
}

rule Component {
    from s : INMODEL!"uml::Component",
         m : INMODEL!"uml::Component" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Component" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isIndirectlyInstantiated <- s.isIndirectlyInstantiated,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        packagedElement <- s.packagedElement,
        realization <- s.realization)
}

rule Node {
    from s : INMODEL!"uml::Node",
         m : INMODEL!"uml::Node" (
		if s.oclIsTypeOf(INMODEL!"uml::Node") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Node") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Node" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        deployment <- s.deployment,
        nestedNode <- s.nestedNode)
}

rule CommunicationPath {
    from s : INMODEL!"uml::CommunicationPath",
         m : INMODEL!"uml::CommunicationPath" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CommunicationPath" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isDerived <- s.isDerived,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedEnd <- s.ownedEnd,
        memberEnd <- s.memberEnd,
        navigableOwnedEnd <- s.navigableOwnedEnd)
}

rule Device {
    from s : INMODEL!"uml::Device",
         m : INMODEL!"uml::Device" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Device" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        deployment <- s.deployment,
        nestedNode <- s.nestedNode)
}

rule ExecutionEnvironment {
    from s : INMODEL!"uml::ExecutionEnvironment",
         m : INMODEL!"uml::ExecutionEnvironment" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExecutionEnvironment" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        deployment <- s.deployment,
        nestedNode <- s.nestedNode)
}

rule CombinedFragment {
    from s : INMODEL!"uml::CombinedFragment",
         m : INMODEL!"uml::CombinedFragment" (
		if s.oclIsTypeOf(INMODEL!"uml::CombinedFragment") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::CombinedFragment") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::CombinedFragment" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        interactionOperator <- s.interactionOperator,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        operand <- s.operand,
        cfragmentGate <- s.cfragmentGate)
}

rule Continuation {
    from s : INMODEL!"uml::Continuation",
         m : INMODEL!"uml::Continuation" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Continuation" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        setting <- s.setting,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering)
}

rule ConsiderIgnoreFragment {
    from s : INMODEL!"uml::ConsiderIgnoreFragment",
         m : INMODEL!"uml::ConsiderIgnoreFragment" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ConsiderIgnoreFragment" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        interactionOperator <- s.interactionOperator,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        covered <- s.covered,
        generalOrdering <- s.generalOrdering,
        operand <- s.operand,
        cfragmentGate <- s.cfragmentGate,
        message <- s.message)
}

rule CreateObjectAction {
    from s : INMODEL!"uml::CreateObjectAction",
         m : INMODEL!"uml::CreateObjectAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CreateObjectAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        classifier <- s.classifier,
        result <- s.result)
}

rule DestroyObjectAction {
    from s : INMODEL!"uml::DestroyObjectAction",
         m : INMODEL!"uml::DestroyObjectAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DestroyObjectAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isDestroyLinks <- s.isDestroyLinks,
        isDestroyOwnedObjects <- s.isDestroyOwnedObjects,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        target <- s.target)
}

rule TestIdentityAction {
    from s : INMODEL!"uml::TestIdentityAction",
         m : INMODEL!"uml::TestIdentityAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TestIdentityAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        first <- s.first,
        second <- s.second,
        result <- s.result)
}

rule ReadSelfAction {
    from s : INMODEL!"uml::ReadSelfAction",
         m : INMODEL!"uml::ReadSelfAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadSelfAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        result <- s.result)
}

rule ReadStructuralFeatureAction {
    from s : INMODEL!"uml::ReadStructuralFeatureAction",
         m : INMODEL!"uml::ReadStructuralFeatureAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadStructuralFeatureAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        structuralFeature <- s.structuralFeature,
        object <- s.object,
        result <- s.result)
}

rule ClearStructuralFeatureAction {
    from s : INMODEL!"uml::ClearStructuralFeatureAction",
         m : INMODEL!"uml::ClearStructuralFeatureAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ClearStructuralFeatureAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        structuralFeature <- s.structuralFeature,
        object <- s.object,
        result <- s.result)
}

rule RemoveStructuralFeatureValueAction {
    from s : INMODEL!"uml::RemoveStructuralFeatureValueAction",
         m : INMODEL!"uml::RemoveStructuralFeatureValueAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::RemoveStructuralFeatureValueAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isRemoveDuplicates <- s.isRemoveDuplicates,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        structuralFeature <- s.structuralFeature,
        object <- s.object,
        value <- s.value,
        result <- s.result,
        removeAt <- s.removeAt)
}

rule AddStructuralFeatureValueAction {
    from s : INMODEL!"uml::AddStructuralFeatureValueAction",
         m : INMODEL!"uml::AddStructuralFeatureValueAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::AddStructuralFeatureValueAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isReplaceAll <- s.isReplaceAll,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        structuralFeature <- s.structuralFeature,
        object <- s.object,
        value <- s.value,
        result <- s.result,
        insertAt <- s.insertAt)
}

rule LinkEndData {
    from s : INMODEL!"uml::LinkEndData",
         m : INMODEL!"uml::LinkEndData" (
		if s.oclIsTypeOf(INMODEL!"uml::LinkEndData") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::LinkEndData") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::LinkEndData" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        value <- s.value,
        end <- s.end,
        qualifier <- s.qualifier)
}

rule QualifierValue {
    from s : INMODEL!"uml::QualifierValue",
         m : INMODEL!"uml::QualifierValue" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::QualifierValue" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        qualifier <- s.qualifier,
        value <- s.value)
}

rule ReadLinkAction {
    from s : INMODEL!"uml::ReadLinkAction",
         m : INMODEL!"uml::ReadLinkAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadLinkAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        endData <- s.endData,
        inputValue <- s.inputValue,
        result <- s.result)
}

rule LinkEndCreationData {
    from s : INMODEL!"uml::LinkEndCreationData",
         m : INMODEL!"uml::LinkEndCreationData" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LinkEndCreationData" (
        __xmiID__ <- s.__xmiID__,
        isReplaceAll <- s.isReplaceAll,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        value <- s.value,
        end <- s.end,
        qualifier <- s.qualifier,
        insertAt <- s.insertAt)
}

rule CreateLinkAction {
    from s : INMODEL!"uml::CreateLinkAction",
         m : INMODEL!"uml::CreateLinkAction" (
		if s.oclIsTypeOf(INMODEL!"uml::CreateLinkAction") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::CreateLinkAction") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::CreateLinkAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        endData <- s.endData,
        inputValue <- s.inputValue)
}

rule DestroyLinkAction {
    from s : INMODEL!"uml::DestroyLinkAction",
         m : INMODEL!"uml::DestroyLinkAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DestroyLinkAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        endData <- s.endData,
        inputValue <- s.inputValue)
}

rule LinkEndDestructionData {
    from s : INMODEL!"uml::LinkEndDestructionData",
         m : INMODEL!"uml::LinkEndDestructionData" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LinkEndDestructionData" (
        __xmiID__ <- s.__xmiID__,
        isDestroyDuplicates <- s.isDestroyDuplicates,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        value <- s.value,
        end <- s.end,
        qualifier <- s.qualifier,
        destroyAt <- s.destroyAt)
}

rule ClearAssociationAction {
    from s : INMODEL!"uml::ClearAssociationAction",
         m : INMODEL!"uml::ClearAssociationAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ClearAssociationAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        object <- s.object,
        association <- s.association)
}

rule BroadcastSignalAction {
    from s : INMODEL!"uml::BroadcastSignalAction",
         m : INMODEL!"uml::BroadcastSignalAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::BroadcastSignalAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        argument <- s.argument,
        onPort <- s.onPort,
        signal <- s.signal)
}

rule SendObjectAction {
    from s : INMODEL!"uml::SendObjectAction",
         m : INMODEL!"uml::SendObjectAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::SendObjectAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        argument <- s.argument,
        onPort <- s.onPort,
        target <- s.target,
        request <- s.request)
}

rule ValueSpecificationAction {
    from s : INMODEL!"uml::ValueSpecificationAction",
         m : INMODEL!"uml::ValueSpecificationAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ValueSpecificationAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        value <- s.value,
        result <- s.result)
}

rule TimeExpression {
    from s : INMODEL!"uml::TimeExpression",
         m : INMODEL!"uml::TimeExpression" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TimeExpression" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        expr <- s.expr,
        observation <- s.observation)
}

rule Duration {
    from s : INMODEL!"uml::Duration",
         m : INMODEL!"uml::Duration" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Duration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        expr <- s.expr,
        observation <- s.observation)
}

rule DurationInterval {
    from s : INMODEL!"uml::DurationInterval",
         m : INMODEL!"uml::DurationInterval" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DurationInterval" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        min <- s.min,
        max <- s.max)
}

rule Interval {
    from s : INMODEL!"uml::Interval",
         m : INMODEL!"uml::Interval" (
		if s.oclIsTypeOf(INMODEL!"uml::Interval") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::Interval") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::Interval" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        min <- s.min,
        max <- s.max)
}

rule TimeConstraint {
    from s : INMODEL!"uml::TimeConstraint",
         m : INMODEL!"uml::TimeConstraint" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TimeConstraint" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        firstEvent <- s.firstEvent,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        constrainedElement <- s.constrainedElement,
        specification <- s.specification)
}

rule IntervalConstraint {
    from s : INMODEL!"uml::IntervalConstraint",
         m : INMODEL!"uml::IntervalConstraint" (
		if s.oclIsTypeOf(INMODEL!"uml::IntervalConstraint") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::IntervalConstraint") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::IntervalConstraint" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        constrainedElement <- s.constrainedElement,
        specification <- s.specification)
}

rule TimeInterval {
    from s : INMODEL!"uml::TimeInterval",
         m : INMODEL!"uml::TimeInterval" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TimeInterval" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        type <- s.type,
        min <- s.min,
        max <- s.max)
}

rule DurationConstraint {
    from s : INMODEL!"uml::DurationConstraint",
         m : INMODEL!"uml::DurationConstraint" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DurationConstraint" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        firstEvent <- s.firstEvent,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        constrainedElement <- s.constrainedElement,
        specification <- s.specification)
}

rule TimeObservation {
    from s : INMODEL!"uml::TimeObservation",
         m : INMODEL!"uml::TimeObservation" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TimeObservation" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        firstEvent <- s.firstEvent,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        event <- s.event)
}

rule DurationObservation {
    from s : INMODEL!"uml::DurationObservation",
         m : INMODEL!"uml::DurationObservation" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DurationObservation" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        firstEvent <- s.firstEvent,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        event <- s.event)
}

rule FinalState {
    from s : INMODEL!"uml::FinalState",
         m : INMODEL!"uml::FinalState" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::FinalState" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        submachine <- s.submachine,
        connection <- s.connection,
        connectionPoint <- s.connectionPoint,
        redefinedState <- s.redefinedState,
        stateInvariant <- s.stateInvariant,
        entry <- s.entry,
        exit <- s.exit,
        doActivity <- s.doActivity,
        deferrableTrigger <- s.deferrableTrigger,
        region <- s.region)
}

rule TimeEvent {
    from s : INMODEL!"uml::TimeEvent",
         m : INMODEL!"uml::TimeEvent" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::TimeEvent" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isRelative <- s.isRelative,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        when <- s.when)
}

rule ReadVariableAction {
    from s : INMODEL!"uml::ReadVariableAction",
         m : INMODEL!"uml::ReadVariableAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadVariableAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        variable <- s.variable,
        result <- s.result)
}

rule ClearVariableAction {
    from s : INMODEL!"uml::ClearVariableAction",
         m : INMODEL!"uml::ClearVariableAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ClearVariableAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        variable <- s.variable)
}

rule AddVariableValueAction {
    from s : INMODEL!"uml::AddVariableValueAction",
         m : INMODEL!"uml::AddVariableValueAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::AddVariableValueAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isReplaceAll <- s.isReplaceAll,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        variable <- s.variable,
        value <- s.value,
        insertAt <- s.insertAt)
}

rule RemoveVariableValueAction {
    from s : INMODEL!"uml::RemoveVariableValueAction",
         m : INMODEL!"uml::RemoveVariableValueAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::RemoveVariableValueAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isRemoveDuplicates <- s.isRemoveDuplicates,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        variable <- s.variable,
        value <- s.value,
        removeAt <- s.removeAt)
}

rule RaiseExceptionAction {
    from s : INMODEL!"uml::RaiseExceptionAction",
         m : INMODEL!"uml::RaiseExceptionAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::RaiseExceptionAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        exception <- s.exception)
}

rule ActionInputPin {
    from s : INMODEL!"uml::ActionInputPin",
         m : INMODEL!"uml::ActionInputPin" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ActionInputPin" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        isOrdered <- s.isOrdered,
        isUnique <- s.isUnique,
        isControl <- s.isControl,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        upperValue <- s.upperValue,
        lowerValue <- s.lowerValue,
        fromAction <- s.fromAction)
}

rule InformationItem {
    from s : INMODEL!"uml::InformationItem",
         m : INMODEL!"uml::InformationItem" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InformationItem" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        represented <- s.represented)
}

rule InformationFlow {
    from s : INMODEL!"uml::InformationFlow",
         m : INMODEL!"uml::InformationFlow" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::InformationFlow" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        templateParameter <- s.templateParameter,
        realization <- s.realization,
        conveyed <- s.conveyed,
        informationSource <- s.informationSource,
        informationTarget <- s.informationTarget,
        realizingActivityEdge <- s.realizingActivityEdge,
        realizingConnector <- s.realizingConnector,
        realizingMessage <- s.realizingMessage)
}

rule ReadExtentAction {
    from s : INMODEL!"uml::ReadExtentAction",
         m : INMODEL!"uml::ReadExtentAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadExtentAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        result <- s.result,
        classifier <- s.classifier)
}

rule ReclassifyObjectAction {
    from s : INMODEL!"uml::ReclassifyObjectAction",
         m : INMODEL!"uml::ReclassifyObjectAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReclassifyObjectAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isReplaceAll <- s.isReplaceAll,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        oldClassifier <- s.oldClassifier,
        newClassifier <- s.newClassifier,
        object <- s.object)
}

rule ReadIsClassifiedObjectAction {
    from s : INMODEL!"uml::ReadIsClassifiedObjectAction",
         m : INMODEL!"uml::ReadIsClassifiedObjectAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadIsClassifiedObjectAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isDirect <- s.isDirect,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        classifier <- s.classifier,
        result <- s.result,
        object <- s.object)
}

rule StartClassifierBehaviorAction {
    from s : INMODEL!"uml::StartClassifierBehaviorAction",
         m : INMODEL!"uml::StartClassifierBehaviorAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::StartClassifierBehaviorAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        object <- s.object)
}

rule ReadLinkObjectEndAction {
    from s : INMODEL!"uml::ReadLinkObjectEndAction",
         m : INMODEL!"uml::ReadLinkObjectEndAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadLinkObjectEndAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        object <- s.object,
        end <- s.end,
        result <- s.result)
}

rule ReadLinkObjectEndQualifierAction {
    from s : INMODEL!"uml::ReadLinkObjectEndQualifierAction",
         m : INMODEL!"uml::ReadLinkObjectEndQualifierAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReadLinkObjectEndQualifierAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        object <- s.object,
        result <- s.result,
        qualifier <- s.qualifier)
}

rule CreateLinkObjectAction {
    from s : INMODEL!"uml::CreateLinkObjectAction",
         m : INMODEL!"uml::CreateLinkObjectAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::CreateLinkObjectAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        endData <- s.endData,
        inputValue <- s.inputValue,
        result <- s.result)
}

rule AcceptEventAction {
    from s : INMODEL!"uml::AcceptEventAction",
         m : INMODEL!"uml::AcceptEventAction" (
		if s.oclIsTypeOf(INMODEL!"uml::AcceptEventAction") then
			thisModule.inElements->includes(s)
		else false endif and 
		if s.oclIsTypeOf(INMODEL!"uml::AcceptEventAction") then
			thisModule.mergeElements->includes(s)
		else false endif)
    to t : OUTMODEL!"uml::AcceptEventAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isUnmarshall <- s.isUnmarshall,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        result <- s.result,
        trigger <- s.trigger)
}

rule AcceptCallAction {
    from s : INMODEL!"uml::AcceptCallAction",
         m : INMODEL!"uml::AcceptCallAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::AcceptCallAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isUnmarshall <- s.isUnmarshall,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        result <- s.result,
        trigger <- s.trigger,
        returnInformation <- s.returnInformation)
}

rule ReplyAction {
    from s : INMODEL!"uml::ReplyAction",
         m : INMODEL!"uml::ReplyAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReplyAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        replyToCall <- s.replyToCall,
        returnInformation <- s.returnInformation,
        replyValue <- s.replyValue)
}

rule UnmarshallAction {
    from s : INMODEL!"uml::UnmarshallAction",
         m : INMODEL!"uml::UnmarshallAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::UnmarshallAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        result <- s.result,
        unmarshallType <- s.unmarshallType,
        object <- s.object)
}

rule ReduceAction {
    from s : INMODEL!"uml::ReduceAction",
         m : INMODEL!"uml::ReduceAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ReduceAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isOrdered <- s.isOrdered,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        reducer <- s.reducer,
        result <- s.result,
        collection <- s.collection)
}

rule StartObjectBehaviorAction {
    from s : INMODEL!"uml::StartObjectBehaviorAction",
         m : INMODEL!"uml::StartObjectBehaviorAction" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::StartObjectBehaviorAction" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isSynchronous <- s.isSynchronous,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        argument <- s.argument,
        onPort <- s.onPort,
        result <- s.result,
        object <- s.object)
}

rule JoinNode {
    from s : INMODEL!"uml::JoinNode",
         m : INMODEL!"uml::JoinNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::JoinNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isCombineDuplicate <- s.isCombineDuplicate,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        joinSpec <- s.joinSpec)
}

rule DataStoreNode {
    from s : INMODEL!"uml::DataStoreNode",
         m : INMODEL!"uml::DataStoreNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::DataStoreNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection)
}

rule ConditionalNode {
    from s : INMODEL!"uml::ConditionalNode",
         m : INMODEL!"uml::ConditionalNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ConditionalNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        mustIsolate <- s.mustIsolate,
        isDeterminate <- s.isDeterminate,
        isAssured <- s.isAssured,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        variable <- s.variable,
        edge <- s.edge,
        node <- s.node,
        clause <- s.clause,
        result <- s.result)
}

rule Clause {
    from s : INMODEL!"uml::Clause",
         m : INMODEL!"uml::Clause" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::Clause" (
        __xmiID__ <- s.__xmiID__,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        test <- s.test,
        body <- s.body,
        predecessorClause <- s.predecessorClause,
        successorClause <- s.successorClause,
        decider <- s.decider,
        bodyOutput <- s.bodyOutput)
}

rule LoopNode {
    from s : INMODEL!"uml::LoopNode",
         m : INMODEL!"uml::LoopNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::LoopNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        mustIsolate <- s.mustIsolate,
        isTestedFirst <- s.isTestedFirst,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        variable <- s.variable,
        edge <- s.edge,
        node <- s.node,
        bodyPart <- s.bodyPart,
        setupPart <- s.setupPart,
        decider <- s.decider,
        test <- s.test,
        result <- s.result,
        loopVariable <- s.loopVariable,
        bodyOutput <- s.bodyOutput,
        loopVariableInput <- s.loopVariableInput)
}

rule ExpansionNode {
    from s : INMODEL!"uml::ExpansionNode",
         m : INMODEL!"uml::ExpansionNode" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExpansionNode" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        ordering <- s.ordering,
        isControlType <- s.isControlType,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        type <- s.type,
        upperBound <- s.upperBound,
        inState <- s.inState,
        selection <- s.selection,
        regionAsOutput <- s.regionAsOutput,
        regionAsInput <- s.regionAsInput)
}

rule ExpansionRegion {
    from s : INMODEL!"uml::ExpansionRegion",
         m : INMODEL!"uml::ExpansionRegion" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ExpansionRegion" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        mustIsolate <- s.mustIsolate,
        mode <- s.mode,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        outgoing <- s.outgoing,
        incoming <- s.incoming,
        inPartition <- s.inPartition,
        inInterruptibleRegion <- s.inInterruptibleRegion,
        redefinedNode <- s.redefinedNode,
        handler <- s.handler,
        localPrecondition <- s.localPrecondition,
        localPostcondition <- s.localPostcondition,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        variable <- s.variable,
        edge <- s.edge,
        node <- s.node,
        inputElement <- s.inputElement,
        outputElement <- s.outputElement)
}

rule ProtocolTransition {
    from s : INMODEL!"uml::ProtocolTransition",
         m : INMODEL!"uml::ProtocolTransition" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::ProtocolTransition" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        kind <- s.kind,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        source <- s.source,
        target <- s.target,
        redefinedTransition <- s.redefinedTransition,
        guard <- s.guard,
        effect <- s.effect,
        trigger <- s.trigger,
        postCondition <- s.postCondition,
        preCondition <- s.preCondition)
}

rule AssociationClass {
    from s : INMODEL!"uml::AssociationClass",
         m : INMODEL!"uml::AssociationClass" (
       thisModule.inElements->includes(s) and 
       thisModule.mergeElements->includes(s))
    to t : OUTMODEL!"uml::AssociationClass" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        isDerived <- s.isDerived,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute,
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization,
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier,
        ownedOperation <- s.ownedOperation,
        ownedReception <- s.ownedReception,
        ownedEnd <- s.ownedEnd,
        memberEnd <- s.memberEnd,
        navigableOwnedEnd <- s.navigableOwnedEnd)
}