-- @atlcompiler emftvm
-- @path MM=/Java2Graph_CaseStudy/java.ecore
-- @path MM1=/Java2Graph_CaseStudy/java.ecore

module JavaRefactorings;
create OUT : MM1 from IN : MM;

rule removeSingletonAnnotation {
	from
		c : MM!ClassDeclaration (c.annotations->exists(a | a.type.type.name = 'Singleton'))
	to 
		c2 : MM1!ClassDeclaration (
			abstractTypeDeclaration <- c.abstractTypeDeclaration,
			annotations <- c.annotations->excluding(c.annotations->select(a | a.type.type.name = 'Singleton')->first()),
			anonymousClassDeclarationOwner <- c.anonymousClassDeclarationOwner,
			bodyDeclarations <- c.bodyDeclarations
						->including(fieldDeclSingleton)
						->including(constructor)
						->including(meth),
			comments <- c.comments,
			commentsAfterBody <- c.commentsAfterBody,
			commentsBeforeBody <- c.commentsBeforeBody,
			modifier <- c.modifier,
			name <- c.name,
			originalClassFile <- c.originalClassFile,
			originalCompilationUnit <- c.originalCompilationUnit,
			package <- c.package,
			proxy <- c.proxy,
			superClass <- c.superClass,
			superInterfaces <- c.superInterfaces,
			typeParameters <- c.typeParameters,
			usagesInImports <- c.usagesInImports,
			usagesInTypeAccess <- c.usagesInTypeAccess
		),
		--- elements to add for: private static ClassName instance = null;
		fieldDeclSingleton : MM1!FieldDeclaration (
			modifier <- modif,
			type <- typeAccess,
			fragments <- varDeclFragment
		),
		modif : MM1!Modifier (
			static <- true,
			visibility <- #private
		),
		typeAccess : MM1!TypeAccess (
			type <- c	
		),
		varDeclFragment : MM1!VariableDeclarationFragment (
			name <- 'instance',
			originalCompilationUnit <- c.originalCompilationUnit,
			variablesContainer <- fieldDeclSingleton,
			initializer <- nullLiteral
		),
		nullLiteral : MM1!NullLiteral (
			originalCompilationUnit <- c.originalCompilationUnit
		),
		--- elements to add for: private ClassName() { }
		constructor : MM1!ConstructorDeclaration (
			modifier <- modC,
			name <- c.name,
			body <- emptyBlock,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		modC : MM1!Modifier (
			visibility <- #private
		),
		emptyBlock : MM1!Block (
			originalCompilationUnit <- c.originalCompilationUnit			
		),
		--- elements to add for: 
		--- public static ClassName getInstance(){
		---	if (instance==null){
		---		instance = new MyBinding();
		---	}
		---	return instance;
		---}
		meth : MM1!MethodDeclaration (
			name <- 'getInstance',
			modifier <- modM,
			body <- block,
			returnType <- typeAccessC
		),
		modM : MM1!Modifier (
			visibility <- #public			
		),
		block : MM1!Block (
			statements <- Sequence{ifStatement, returnStatement}
		),
		typeAccessC : MM1!TypeAccess (
			type <- c		
		),
		ifStatement : MM1!IfStatement (
			expression <- infixExp,
			thenStatement <- ifBlock,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		infixExp : MM1!InfixExpression (
			leftOperand <- singlVarAcc,
			rightOperand <- nullLit,
			operator <- #EQUALS
		),
		singlVarAcc : MM1!SingleVariableAccess (
			variable <- varDeclFragment,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		nullLit : MM1!NullLiteral (
			originalCompilationUnit <- c.originalCompilationUnit
		),
		ifBlock : MM1!Block (
			statements <- Sequence{expressionStatement},
			originalCompilationUnit <- c.originalCompilationUnit
		),
		expressionStatement : MM1!ExpressionStatement (
			expression <- exprAssignment,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		exprAssignment : MM1!Assignment (
			leftHandSide <- singlVarAccess,
			rightHandSide <- classInstanceCreation,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		singlVarAccess : MM1!SingleVariableAccess (
			variable <- varDeclFragment,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		classInstanceCreation : MM1!ClassInstanceCreation (
			type <- typeAccess2,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		typeAccess2 : MM1!TypeAccess (
			type <- c,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		returnStatement : MM1!ReturnStatement (
			expression <- singleVarAccess
		),
		singleVarAccess : MM1!SingleVariableAccess (
			variable <- varDeclFragment,
			originalCompilationUnit <- c.originalCompilationUnit
		)
}

rule privateConstructorDeclaration {
	from 
		c : MM!ConstructorDeclaration (if not c.abstractTypeDeclaration.oclIsUndefined() then 
			   		c.abstractTypeDeclaration.annotations->exists(a | a.type.type.name = 'Singleton') else false endif)
	to 
		c2 : MM1!ConstructorDeclaration (
			modifier <- modif,
			abstractTypeDeclaration <- c.abstractTypeDeclaration,
			annotations <- c.annotations,
			anonymousClassDeclarationOwner <- c.anonymousClassDeclarationOwner,
			body <- c.body,
			comments <- c.comments,
			name <- c.name,
			originalClassFile <- c.originalClassFile,
			originalCompilationUnit <- c.originalCompilationUnit,
			parameters <- c.parameters,
			proxy <- c.proxy,
			thrownExceptions <- c.thrownExceptions,
			typeParameters <- c.typeParameters,
			usages <- c.usages,
			usagesInDocComments <- c.usagesInDocComments,
			usagesInImports <- c.usagesInImports
		),
		modif : MM1!Modifier (
			visibility <- #private,
			static <- c.modifier.static,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		--- creation of new method getInstance with the proper parameters (with the same parameters the constructor has)
		getInstanceMethod : MM1!MethodDeclaration (
			parameters <- c.parameters->collect(p | thisModule.createParams(p)),
			name <- 'getInstance',
			modifier <- modM,
			originalCompilationUnit <- c.originalCompilationUnit,
			originalClassFile <- c.originalClassFile,
			abstractTypeDeclaration <- c.abstractTypeDeclaration,
			body <- block,
			returnType <- typeAccessC
		),
		modM : MM1!Modifier (
			visibility <- #public			
		),
		block : MM1!Block (
			statements <- Sequence{ifStatement, returnStatement}
		),
		typeAccessC : MM1!TypeAccess (
			type <- c.abstractTypeDeclaration		
		),
		ifStatement : MM1!IfStatement (
			expression <- infixExp,
			thenStatement <- ifBlock,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		infixExp : MM1!InfixExpression (
			leftOperand <- singlVarAcc,
			rightOperand <- nullLit,
			operator <- #EQUALS
		),
		singlVarAcc : MM1!SingleVariableAccess (
			variable <- thisModule.resolveTemp(c.abstractTypeDeclaration, 'varDeclFragment'),
			originalCompilationUnit <- c.originalCompilationUnit
		),
		nullLit : MM1!NullLiteral (
			originalCompilationUnit <- c.originalCompilationUnit
		),
		ifBlock : MM1!Block (
			statements <- Sequence{expressionStatement},
			originalCompilationUnit <- c.originalCompilationUnit
		),
		expressionStatement : MM1!ExpressionStatement (
			expression <- exprAssignment,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		exprAssignment : MM1!Assignment (
			leftHandSide <- singlVarAccess,
			rightHandSide <- classInstanceCreation,
			operator <- #ASSIGN,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		singlVarAccess : MM1!SingleVariableAccess (
			variable <- thisModule.resolveTemp(c.abstractTypeDeclaration, 'varDeclFragment'),
			originalCompilationUnit <- c.originalCompilationUnit
		),
		classInstanceCreation : MM1!ClassInstanceCreation (
			type <- typeAccess2,
			originalCompilationUnit <- c.originalCompilationUnit,
			arguments <- c.parameters->collect(t | t.type)
		),
		typeAccess2 : MM1!TypeAccess (
			type <- c.abstractTypeDeclaration,
			originalCompilationUnit <- c.originalCompilationUnit
		),
		returnStatement : MM1!ReturnStatement (
			expression <- singleVarAccess
		),
		singleVarAccess : MM1!SingleVariableAccess (
			variable <- thisModule.resolveTemp(c.abstractTypeDeclaration, 'varDeclFragment'),
			originalCompilationUnit <- c.originalCompilationUnit
		)
}

lazy rule createParams {
	from
		p : MM!SingleVariableDeclaration
	to 
		p2 : MM1!SingleVariableDeclaration (
			name <- p.name,
			type <- p.type,
			originalCompilationUnit <- p.originalCompilationUnit,
			varargs <- p.varargs,
			initializer <- p.initializer,
			modifier <- p.modifier,
			methodDeclaration <- thisModule.resolveTemp(p.methodDeclaration, 'getInstanceMethod')
		)
}

rule ConstructorDeclaration {
			from
			   inn : MM!ConstructorDeclaration (if not inn.abstractTypeDeclaration.oclIsUndefined() then 
			   		not inn.abstractTypeDeclaration.annotations->exists(a | a.type.type.name = 'Singleton') else true endif)
			to
			   out : MM1!ConstructorDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				parameters <- if inn.parameters.oclIsUndefined() then OclUndefined else inn.parameters endif,
				thrownExceptions <- if inn.thrownExceptions.oclIsUndefined() then OclUndefined else inn.thrownExceptions endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif,
				usagesInDocComments <- if inn.usagesInDocComments.oclIsUndefined() then OclUndefined else inn.usagesInDocComments endif,
				usages <- if inn.usages.oclIsUndefined() then OclUndefined else inn.usages endif
				)
		}

-- ------------------------------------------
-- From now on the transfo is the identity --
-- ------------------------------------------

rule Annotation{
			from
			   inn : MM!Annotation
			to
			   out : MM1!Annotation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				values <- if inn.values.oclIsUndefined() then OclUndefined else inn.values endif				)
		}
		 		

		
		rule Archive{
			from
			   inn : MM!Archive
			to
			   out : MM1!Archive (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				originalFilePath <- inn.originalFilePath				,
				classFiles <- if inn.classFiles.oclIsUndefined() then OclUndefined else inn.classFiles endif,
				manifest <- if inn.manifest.oclIsUndefined() then OclUndefined else inn.manifest endif				)
		}
		 		

		
		rule AssertStatement{
			from
			   inn : MM!AssertStatement
			to
			   out : MM1!AssertStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				message <- if inn.message.oclIsUndefined() then OclUndefined else inn.message endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 
		rule AnnotationMemberValuePair{
			from
			   inn : MM!AnnotationMemberValuePair
			to
			   out : MM1!AnnotationMemberValuePair (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name,
				proxy <- inn.proxy,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				member <- if inn.member.oclIsUndefined() then OclUndefined else inn.member endif,
				value <- if inn.value.oclIsUndefined() then OclUndefined else inn.value endif				)
		}
		 		

		
		rule AnnotationTypeDeclaration{
			from
			   inn : MM!AnnotationTypeDeclaration
			to
			   out : MM1!AnnotationTypeDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if (inn.usagesInTypeAccess.oclIsUndefined() ) then OclUndefined else inn.usagesInTypeAccess endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif				)
		}
		 		

		
		rule AnnotationTypeMemberDeclaration{
			from
			   inn : MM!AnnotationTypeMemberDeclaration
			to
			   out : MM1!AnnotationTypeMemberDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				default <- if inn.default.oclIsUndefined() then OclUndefined else inn.default endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif--,
				-- usages <- if inn.usages.oclIsUndefined() then OclUndefined else inn.usages endif				
				)
		}
		 		

		
		rule AnonymousClassDeclaration{
			from
			   inn : MM!AnonymousClassDeclaration
			to
			   out : MM1!AnonymousClassDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				classInstanceCreation <- if inn.classInstanceCreation.oclIsUndefined() then OclUndefined else inn.classInstanceCreation endif				)
		}
		 		

		
		rule ArrayAccess{
			from
			   inn : MM!ArrayAccess
			to
			   out : MM1!ArrayAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				array <- if inn.array.oclIsUndefined() then OclUndefined else inn.array endif,
				index <- if inn.index.oclIsUndefined() then OclUndefined else inn.index endif				)
		}
		 		

		
		rule ArrayCreation{
			from
			   inn : MM!ArrayCreation
			to
			   out : MM1!ArrayCreation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				dimensions <- if inn.dimensions.oclIsUndefined() then OclUndefined else inn.dimensions endif,
				initializer <- if inn.initializer.oclIsUndefined() then OclUndefined else inn.initializer endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif				)
		}
		 		

		
		rule ArrayInitializer{
			from
			   inn : MM!ArrayInitializer
			to
			   out : MM1!ArrayInitializer (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expressions <- if inn.expressions.oclIsUndefined() then OclUndefined else inn.expressions endif				)
		}
		 		

		
		rule ArrayLengthAccess{
			from
			   inn : MM!ArrayLengthAccess
			to
			   out : MM1!ArrayLengthAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				array <- if inn.array.oclIsUndefined() then OclUndefined else inn.array endif				)
		}
		 		

		
		rule ArrayType{
			from
			   inn : MM!ArrayType
			to
			   out : MM1!ArrayType (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				dimensions <- inn.dimensions				,
				elementType <- if inn.elementType.oclIsUndefined() then OclUndefined else inn.elementType endif				)
		}
		 		

		
		rule Assignment{
			from
			   inn : MM!Assignment
			to
			   out : MM1!Assignment (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				leftHandSide <- if inn.leftHandSide.oclIsUndefined() then OclUndefined else inn.leftHandSide endif,
				operator <- inn.operator				,
				rightHandSide <- if inn.rightHandSide.oclIsUndefined() then OclUndefined else inn.rightHandSide endif				)
		}
		 		

		 		

		
		rule BooleanLiteral{
			from
			   inn : MM!BooleanLiteral
			to
			   out : MM1!BooleanLiteral (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				value <- inn.value								)
		}
		 		

		
		rule BlockComment{
			from
			   inn : MM!BlockComment
			to
			   out : MM1!BlockComment (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				content <- inn.content				,
				enclosedByParent <- inn.enclosedByParent				,
				prefixOfParent <- inn.prefixOfParent								)
		}
		 		

		
		rule Block{
			from
			   inn : MM!Block
			to
			   out : MM1!Block (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				statements <- if inn.statements.oclIsUndefined() then OclUndefined else inn.statements endif				)
		}
		 		

		
		rule BreakStatement{
			from
			   inn : MM!BreakStatement
			to
			   out : MM1!BreakStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				label <- if inn.label.oclIsUndefined() then OclUndefined else inn.label endif				)
		}
		 		

		
		rule CastExpression{
			from
			   inn : MM!CastExpression
			to
			   out : MM1!CastExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif				)
		}
		 		

		
		rule CatchClause{
			from
			   inn : MM!CatchClause
			to
			   out : MM1!CatchClause (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				exception <- if inn.exception.oclIsUndefined() then OclUndefined else inn.exception endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif				)
		}
		 		

		
		rule CharacterLiteral{
			from
			   inn : MM!CharacterLiteral
			to
			   out : MM1!CharacterLiteral (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				escapedValue <- inn.escapedValue								)
		}
		 		

		
		rule ClassFile{
			from
			   inn : MM!ClassFile
			to
			   out : MM1!ClassFile (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				originalFilePath <- inn.originalFilePath				,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				attachedSource <- if inn.attachedSource.oclIsUndefined() then OclUndefined else inn.attachedSource endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif				)
		}
		 		

		
		rule ClassInstanceCreation{
			from
			   inn : MM!ClassInstanceCreation
			to
			   out : MM1!ClassInstanceCreation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				method <- if inn.method.oclIsUndefined() then OclUndefined else inn.method endif,
				arguments <- if inn.arguments.oclIsUndefined() then OclUndefined else inn.arguments endif,
				typeArguments <- if inn.typeArguments.oclIsUndefined() then OclUndefined else inn.typeArguments endif,
				anonymousClassDeclaration <- if inn.anonymousClassDeclaration.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclaration endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif				)
		}
		 		

		
		rule ConditionalExpression{
			from
			   inn : MM!ConditionalExpression
			to
			   out : MM1!ConditionalExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				elseExpression <- if inn.elseExpression.oclIsUndefined() then OclUndefined else inn.elseExpression endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				thenExpression <- if inn.thenExpression.oclIsUndefined() then OclUndefined else inn.thenExpression endif				)
		}
		 		

		
		rule ConstructorInvocation{
			from
			   inn : MM!ConstructorInvocation
			to
			   out : MM1!ConstructorInvocation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				method <- if inn.method.oclIsUndefined() then OclUndefined else inn.method endif,
				arguments <- if inn.arguments.oclIsUndefined() then OclUndefined else inn.arguments endif,
				typeArguments <- if inn.typeArguments.oclIsUndefined() then OclUndefined else inn.typeArguments endif				)
		}
		 		

		
		rule ClassDeclaration{
			from
			   inn : MM!ClassDeclaration (not inn.annotations->exists(a | a.type.type.name = 'Singleton'))
			to
			   out : MM1!ClassDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				-- bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif,
				superClass <- if inn.superClass.oclIsUndefined() then OclUndefined else inn.superClass endif				)
		}
		 		

		 		

		
		rule CompilationUnit{
			from
			   inn : MM!CompilationUnit
			to
			   out : MM1!CompilationUnit (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				originalFilePath <- inn.originalFilePath				,
				commentList <- if inn.commentList.oclIsUndefined() then OclUndefined else inn.commentList endif,
				imports <- if inn.imports.oclIsUndefined() then OclUndefined else inn.imports endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				types <- if inn.types.oclIsUndefined() then OclUndefined else inn.types endif				)
		}
		 		

		
		rule ContinueStatement{
			from
			   inn : MM!ContinueStatement
			to
			   out : MM1!ContinueStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				label <- if inn.label.oclIsUndefined() then OclUndefined else inn.label endif				)
		}
		 		

		
		rule DoStatement{
			from
			   inn : MM!DoStatement
			to
			   out : MM1!DoStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif				)
		}
		 		

		
		rule EmptyStatement{
			from
			   inn : MM!EmptyStatement
			to
			   out : MM1!EmptyStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif				)
		}
		 		

		
		rule EnhancedForStatement{
			from
			   inn : MM!EnhancedForStatement
			to
			   out : MM1!EnhancedForStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				parameter <- if inn.parameter.oclIsUndefined() then OclUndefined else inn.parameter endif				)
		}
		 		

		
		rule EnumConstantDeclaration{
			from
			   inn : MM!EnumConstantDeclaration
			to
			   out : MM1!EnumConstantDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				initializer <- if inn.initializer.oclIsUndefined() then OclUndefined else inn.initializer endif,
				usageInVariableAccess <- if inn.usageInVariableAccess.oclIsUndefined() then OclUndefined else inn.usageInVariableAccess endif,
				anonymousClassDeclaration <- if inn.anonymousClassDeclaration.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclaration endif,
				arguments <- if inn.arguments.oclIsUndefined() then OclUndefined else inn.arguments endif				)
		}
		 		

		
		rule EnumDeclaration{
			from
			   inn : MM!EnumDeclaration
			to
			   out : MM1!EnumDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				-- bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif,
				enumConstants <- if inn.enumConstants.oclIsUndefined() then OclUndefined else inn.enumConstants endif				)
		}
		 		

		 		

		
		rule ExpressionStatement{
			from
			   inn : MM!ExpressionStatement
			to
			   out : MM1!ExpressionStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule FieldAccess{
			from
			   inn : MM!FieldAccess
			to
			   out : MM1!FieldAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				field <- if inn.field.oclIsUndefined() then OclUndefined else inn.field endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule FieldDeclaration{
			from
			   inn : MM!FieldDeclaration
			to
			   out : MM1!FieldDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				fragments <- if inn.fragments.oclIsUndefined() then OclUndefined else inn.fragments endif				)
		}
		 		

		
		rule ForStatement{
			from
			   inn : MM!ForStatement
			to
			   out : MM1!ForStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				updaters <- if inn.updaters.oclIsUndefined() then OclUndefined else inn.updaters endif,
				initializers <- if inn.initializers.oclIsUndefined() then OclUndefined else inn.initializers endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif				)
		}
		 		

		
		rule IfStatement{
			from
			   inn : MM!IfStatement
			to
			   out : MM1!IfStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				thenStatement <- if inn.thenStatement.oclIsUndefined() then OclUndefined else inn.thenStatement endif,
				elseStatement <- if inn.elseStatement.oclIsUndefined() then OclUndefined else inn.elseStatement endif				)
		}
		 		

		
		rule ImportDeclaration{
			from
			   inn : MM!ImportDeclaration
			to
			   out : MM1!ImportDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				static <- inn.static				,
				importedElement <- if inn.importedElement.oclIsUndefined() then OclUndefined else inn.importedElement endif				)
		}
		 		

		
		rule InfixExpression{
			from
			   inn : MM!InfixExpression
			to
			   out : MM1!InfixExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				operator <- inn.operator				,
				rightOperand <- if inn.rightOperand.oclIsUndefined() then OclUndefined else inn.rightOperand endif,
				leftOperand <- if inn.leftOperand.oclIsUndefined() then OclUndefined else inn.leftOperand endif,
				extendedOperands <- if inn.extendedOperands.oclIsUndefined() then OclUndefined else inn.extendedOperands endif				)
		}
		 		

		
		rule Initializer{
			from
			   inn : MM!Initializer
			to
			   out : MM1!Initializer (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif				)
		}
		 		

		
		rule InstanceofExpression{
			from
			   inn : MM!InstanceofExpression
			to
			   out : MM1!InstanceofExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				rightOperand <- if inn.rightOperand.oclIsUndefined() then OclUndefined else inn.rightOperand endif,
				leftOperand <- if inn.leftOperand.oclIsUndefined() then OclUndefined else inn.leftOperand endif				)
		}
		 		

		
		rule InterfaceDeclaration{
			from
			   inn : MM!InterfaceDeclaration
			to
			   out : MM1!InterfaceDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				-- bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif				)
		}

		
		rule Javadoc{
			from
			   inn : MM!Javadoc
			to
			   out : MM1!Javadoc (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				content <- inn.content				,
				enclosedByParent <- inn.enclosedByParent				,
				prefixOfParent <- inn.prefixOfParent				,
				tags <- if inn.tags.oclIsUndefined() then OclUndefined else inn.tags endif				)
		}
		 		

		
		rule LabeledStatement{
			from
			   inn : MM!LabeledStatement (not inn.oclIsTypeOf(MM!UnresolvedLabeledStatement))
			to
			   out : MM1!LabeledStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				usagesInBreakStatements <- if inn.usagesInBreakStatements.oclIsUndefined() then OclUndefined else inn.usagesInBreakStatements endif,
				usagesInContinueStatements <- if inn.usagesInContinueStatements.oclIsUndefined() then OclUndefined else inn.usagesInContinueStatements endif				)
		}
		 		

		
		rule LineComment{
			from
			   inn : MM!LineComment
			to
			   out : MM1!LineComment (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				content <- inn.content				,
				enclosedByParent <- inn.enclosedByParent				,
				prefixOfParent <- inn.prefixOfParent								)
		}
		 		

		
		rule Manifest{
			from
			   inn : MM!Manifest
			to
			   out : MM1!Manifest (
				mainAttributes <- if inn.mainAttributes.oclIsUndefined() then OclUndefined else inn.mainAttributes endif,
				entryAttributes <- if inn.entryAttributes.oclIsUndefined() then OclUndefined else inn.entryAttributes endif
				)
		}
		 		

		
		rule ManifestAttribute{
			from
			   inn : MM!ManifestAttribute
			to
			   out : MM1!ManifestAttribute (
				key <- inn.key,
				value <- inn.value
				)
		}
		 		

		
		rule ManifestEntry{
			from
			   inn : MM!ManifestEntry
			to
			   out : MM1!ManifestEntry (
				name <- inn.name				,
				attributes <- if inn.attributes.oclIsUndefined() then OclUndefined else inn.attributes endif				)
		}
		 		

		
		rule MemberRef{
			from
			   inn : MM!MemberRef
			to
			   out : MM1!MemberRef (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				member <- if inn.member.oclIsUndefined() then OclUndefined else inn.member endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif				)
		}
		 		

		
		rule MethodDeclaration{
			from
			   inn : MM!MethodDeclaration
			to
			   out : MM1!MethodDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				--originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				parameters <- if inn.parameters.oclIsUndefined() then OclUndefined else inn.parameters endif,
				thrownExceptions <- if inn.thrownExceptions.oclIsUndefined() then OclUndefined else inn.thrownExceptions endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif,
				-- usagesInDocComments <- if inn.usagesInDocComments.oclIsUndefined() then OclUndefined else inn.usagesInDocComments endif,
				-- usages <- if inn.usages.oclIsUndefined() then OclUndefined else inn.usages endif,
				-- extraArrayDimensions <- inn.extraArrayDimensions				,
				returnType <- if inn.returnType.oclIsUndefined() then OclUndefined else inn.returnType endif--,
				-- redefinedMethodDeclaration <- if inn.redefinedMethodDeclaration.oclIsUndefined() then OclUndefined else inn.redefinedMethodDeclaration endif--,
				-- redefinitions <- if inn.redefinitions.oclIsUndefined() then OclUndefined else inn.redefinitions endif
				, originalCompilationUnit <- inn.originalCompilationUnit
				)
		}
		 		

		
		rule MethodInvocation{
			from
			   inn : MM!MethodInvocation
			to
			   out : MM1!MethodInvocation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				method <- if inn.method.oclIsUndefined() then OclUndefined else inn.method endif,
				arguments <- if inn.arguments.oclIsUndefined() then OclUndefined else inn.arguments endif,
				typeArguments <- if inn.typeArguments.oclIsUndefined() then OclUndefined else inn.typeArguments endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule MethodRef{
			from
			   inn : MM!MethodRef
			to
			   out : MM1!MethodRef (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				method <- if inn.method.oclIsUndefined() then OclUndefined else inn.method endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif,
				parameters <- if inn.parameters.oclIsUndefined() then OclUndefined else inn.parameters endif				)
		}
		 		

		
		rule MethodRefParameter{
			from
			   inn : MM!MethodRefParameter
			to
			   out : MM1!MethodRefParameter (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				varargs <- inn.varargs				,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif				)
		}
		 		

		
		rule Model{
			from
			   inn : MM!Model
			to
			   out : MM1!Model (
				name <- inn.name				,
				ownedElements <- if inn.ownedElements.oclIsUndefined() then OclUndefined else inn.ownedElements endif,
				orphanTypes <- if inn.orphanTypes.oclIsUndefined() then OclUndefined else inn.orphanTypes endif,
				-- unresolvedItems <- if inn.unresolvedItems.oclIsUndefined() then OclUndefined else inn.unresolvedItems endif,
				compilationUnits <- if inn.compilationUnits.oclIsUndefined() then OclUndefined else inn.compilationUnits endif,
				classFiles <- if inn.classFiles.oclIsUndefined() then OclUndefined else inn.classFiles endif,
				archives <- if inn.archives.oclIsUndefined() then OclUndefined else inn.archives endif				)
		}
		 		

		
		rule Modifier{
			from
			   inn : MM!Modifier
			to
			   out : MM1!Modifier (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				visibility <- inn.visibility				,
				inheritance <- inn.inheritance				,
				static <- inn.static				,
				transient <- inn.transient				,
				volatile <- inn.volatile				,
				native <- inn.native				,
				strictfp <- inn.strictfp				,
				synchronized <- inn.synchronized				,
				-- bodyDeclaration <- if inn.bodyDeclaration.oclIsUndefined() then OclUndefined else inn.bodyDeclaration endif,
				singleVariableDeclaration <- if inn.singleVariableDeclaration.oclIsUndefined() then OclUndefined else inn.singleVariableDeclaration endif,
				variableDeclarationStatement <- if inn.variableDeclarationStatement.oclIsUndefined() then OclUndefined else inn.variableDeclarationStatement endif,
				variableDeclarationExpression <- if inn.variableDeclarationExpression.oclIsUndefined() then OclUndefined else inn.variableDeclarationExpression endif				)
		}
		 		

		 		

		 		

		
		rule NumberLiteral{
			from
			   inn : MM!NumberLiteral
			to
			   out : MM1!NumberLiteral (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				tokenValue <- inn.tokenValue								)
		}
		 		

		
		rule NullLiteral{
			from
			   inn : MM!NullLiteral
			to
			   out : MM1!NullLiteral (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif				)
		}
		 		

		
		rule Package{
			from
			   inn : MM!Package
			to
			   out : MM1!Package (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				ownedElements <- if inn.ownedElements.oclIsUndefined() then OclUndefined else inn.ownedElements endif,
				model <- if inn.model.oclIsUndefined() then OclUndefined else inn.model endif,
				ownedPackages <- if inn.ownedPackages.oclIsUndefined() then OclUndefined else inn.ownedPackages endif--,
				-- package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				-- usagesInPackageAccess <- if inn.usagesInPackageAccess.oclIsUndefined() then OclUndefined else inn.usagesInPackageAccess endif				
				)
		}
		 		

		
		rule PackageAccess{
			from
			   inn : MM!PackageAccess
			to
			   out : MM1!PackageAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif				)
		}
		 		

		
		rule ParameterizedType{
			from
			   inn : MM!ParameterizedType
			to
			   out : MM1!ParameterizedType (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				typeArguments <- if inn.typeArguments.oclIsUndefined() then OclUndefined else inn.typeArguments endif				)
		}
		 		

		
		rule ParenthesizedExpression{
			from
			   inn : MM!ParenthesizedExpression
			to
			   out : MM1!ParenthesizedExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule PostfixExpression{
			from
			   inn : MM!PostfixExpression
			to
			   out : MM1!PostfixExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				operator <- inn.operator				,
				operand <- if inn.operand.oclIsUndefined() then OclUndefined else inn.operand endif				)
		}
		 		

		
		rule PrefixExpression{
			from
			   inn : MM!PrefixExpression
			to
			   out : MM1!PrefixExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				operator <- inn.operator				,
				operand <- if inn.operand.oclIsUndefined() then OclUndefined else inn.operand endif				)
		}
		 		

		
		rule PrimitiveType{
			from
			   inn : MM!PrimitiveType (not inn.oclIsTypeOf(MM!PrimitiveTypeVoid) and 
			not inn.oclIsTypeOf(MM!PrimitiveTypeByte) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeDouble) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeChar) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeFloat) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeLong) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeInt) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeBoolean) and
			not inn.oclIsTypeOf(MM!PrimitiveTypeShort))
			to
			   out : MM1!PrimitiveType (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif	
				)
		}
		 		

		
		rule PrimitiveTypeBoolean{
			from
			   inn : MM!PrimitiveTypeBoolean
			to
			   out : MM1!PrimitiveTypeBoolean (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeByte{
			from
			   inn : MM!PrimitiveTypeByte
			to
			   out : MM1!PrimitiveTypeByte (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeChar{
			from
			   inn : MM!PrimitiveTypeChar
			to
			   out : MM1!PrimitiveTypeChar (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeDouble{
			from
			   inn : MM!PrimitiveTypeDouble
			to
			   out : MM1!PrimitiveTypeDouble (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeShort{
			from
			   inn : MM!PrimitiveTypeShort
			to
			   out : MM1!PrimitiveTypeShort (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeFloat{
			from
			   inn : MM!PrimitiveTypeFloat
			to
			   out : MM1!PrimitiveTypeFloat (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeInt{
			from
			   inn : MM!PrimitiveTypeInt
			to
			   out : MM1!PrimitiveTypeInt (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeLong{
			from
			   inn : MM!PrimitiveTypeLong
			to
			   out : MM1!PrimitiveTypeLong (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule PrimitiveTypeVoid{
			from
			   inn : MM!PrimitiveTypeVoid
			to
			   out : MM1!PrimitiveTypeVoid (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule ReturnStatement{
			from
			   inn : MM!ReturnStatement
			to
			   out : MM1!ReturnStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule SingleVariableAccess{
			from
			   inn : MM!SingleVariableAccess
			to
			   out : MM1!SingleVariableAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				--variable <- if inn.variable.oclIsUndefined() then OclUndefined else inn.variable endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif				)
		}
		 		

		
		rule SingleVariableDeclaration{
			from
			   inn : MM!SingleVariableDeclaration
			to
			   out : MM1!SingleVariableDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				initializer <- if inn.initializer.oclIsUndefined() then OclUndefined else inn.initializer endif,
				usageInVariableAccess <- if inn.usageInVariableAccess.oclIsUndefined() then OclUndefined else inn.usageInVariableAccess endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				varargs <- inn.varargs				,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				-- methodDeclaration <- if inn.methodDeclaration.oclIsUndefined() then OclUndefined else inn.methodDeclaration endif,
				catchClause <- if inn.catchClause.oclIsUndefined() then OclUndefined else inn.catchClause endif,
				enhancedForStatement <- if inn.enhancedForStatement.oclIsUndefined() then OclUndefined else inn.enhancedForStatement endif				)
		}
		 		

		 		

		
		rule StringLiteral{
			from
			   inn : MM!StringLiteral
			to
			   out : MM1!StringLiteral (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				escapedValue <- inn.escapedValue								)
		}
		 		

		
		rule SuperConstructorInvocation{
			from
			   inn : MM!SuperConstructorInvocation
			to
			   out : MM1!SuperConstructorInvocation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				method <- if inn.method.oclIsUndefined() then OclUndefined else inn.method endif,
				arguments <- if inn.arguments.oclIsUndefined() then OclUndefined else inn.arguments endif,
				typeArguments <- if inn.typeArguments.oclIsUndefined() then OclUndefined else inn.typeArguments endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule SuperFieldAccess{
			from
			   inn : MM!SuperFieldAccess
			to
			   out : MM1!SuperFieldAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif,
				field <- if inn.field.oclIsUndefined() then OclUndefined else inn.field endif				)
		}
		 		

		
		rule SuperMethodInvocation{
			from
			   inn : MM!SuperMethodInvocation
			to
			   out : MM1!SuperMethodInvocation (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif,
				method <- if inn.method.oclIsUndefined() then OclUndefined else inn.method endif,
				arguments <- if inn.arguments.oclIsUndefined() then OclUndefined else inn.arguments endif,
				typeArguments <- if inn.typeArguments.oclIsUndefined() then OclUndefined else inn.typeArguments endif				)
		}
		 		

		
		rule SwitchCase{
			from
			   inn : MM!SwitchCase
			to
			   out : MM1!SwitchCase (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				default <- inn.default				,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule SwitchStatement{
			from
			   inn : MM!SwitchStatement
			to
			   out : MM1!SwitchStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				statements <- if inn.statements.oclIsUndefined() then OclUndefined else inn.statements endif				)
		}
		 		

		
		rule SynchronizedStatement{
			from
			   inn : MM!SynchronizedStatement
			to
			   out : MM1!SynchronizedStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule TagElement{
			from
			   inn : MM!TagElement
			to
			   out : MM1!TagElement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				tagName <- inn.tagName				,
				fragments <- if inn.fragments.oclIsUndefined() then OclUndefined else inn.fragments endif				)
		}
		 		

		
		rule TextElement{
			from
			   inn : MM!TextElement
			to
			   out : MM1!TextElement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				text <- inn.text								)
		}
		 		

		
		rule ThisExpression{
			from
			   inn : MM!ThisExpression
			to
			   out : MM1!ThisExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif				)
		}
		 		

		
		rule ThrowStatement{
			from
			   inn : MM!ThrowStatement
			to
			   out : MM1!ThrowStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif				)
		}
		 		

		
		rule TryStatement{
			from
			   inn : MM!TryStatement
			to
			   out : MM1!TryStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				finally <- if inn.finally.oclIsUndefined() then OclUndefined else inn.finally endif,
				catchClauses <- if inn.catchClauses.oclIsUndefined() then OclUndefined else inn.catchClauses endif				)
		}
		 		

		 		

		
		rule TypeAccess{
			from
			   inn : MM!TypeAccess
			to
			   out : MM1!TypeAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				-- type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif				)
		}
		 		

		 		

		
		rule TypeDeclarationStatement{
			from
			   inn : MM!TypeDeclarationStatement
			to
			   out : MM1!TypeDeclarationStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				declaration <- if inn.declaration.oclIsUndefined() then OclUndefined else inn.declaration endif				)
		}
		 		

		
		rule TypeLiteral{
			from
			   inn : MM!TypeLiteral
			to
			   out : MM1!TypeLiteral (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif				)
		}
		 		

		
		rule TypeParameter{
			from
			   inn : MM!TypeParameter
			to
			   out : MM1!TypeParameter (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				bounds <- if inn.bounds.oclIsUndefined() then OclUndefined else inn.bounds endif				)
		}
		 		

		
		rule UnresolvedItem{
			from
			   inn : MM!UnresolvedItem  (not inn.oclIsTypeOf(MM!UnresolvedLabeledStatement) and 
			not inn.oclIsTypeOf(MM!UnresolvedItemAccess) and
			not inn.oclIsTypeOf(MM!UnresolvedAnnotationDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedClassDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedMethodDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedTypeDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedEnumDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedAnnotationTypeMemberDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedInterfaceDeclaration) and
			not inn.oclIsTypeOf(MM!UnresolvedType) and
			not inn.oclIsTypeOf(MM!UnresolvedVariableDeclarationFragment) and
			not inn.oclIsTypeOf(MM!UnresolvedSingleVariableDeclaration)	)
			to
			   out : MM1!UnresolvedItem (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif				
				)
		}
		 		

		
		rule UnresolvedItemAccess{
			from
			   inn : MM!UnresolvedItemAccess
			to
			   out : MM1!UnresolvedItemAccess (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				--element <- if inn.element.oclIsUndefined() then OclUndefined else inn.element endif,
				qualifier <- if inn.qualifier.oclIsUndefined() then OclUndefined else inn.qualifier endif				)
		}
		 		

		
		rule UnresolvedAnnotationDeclaration{
			from
			   inn : MM!UnresolvedAnnotationDeclaration (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!AnnotationTypeDeclaration))
			to
			   out : MM1!UnresolvedAnnotationDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif				)
		}
		 		

		
		rule UnresolvedAnnotationTypeMemberDeclaration{
			from
			   inn : MM!UnresolvedAnnotationTypeMemberDeclaration (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!AnnotationTypeMemberDeclaration))
			to
			   out : MM1!UnresolvedAnnotationTypeMemberDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				default <- if inn.default.oclIsUndefined() then OclUndefined else inn.default endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif--,
				-- usages <- if inn.usages.oclIsUndefined() then OclUndefined else inn.usages endif				
				)
		}
		 		

		
		rule UnresolvedClassDeclaration{
			from
			   inn : MM!UnresolvedClassDeclaration (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!ClassDeclaration))
			to
			   out : MM1!UnresolvedClassDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif,
				superClass <- if inn.superClass.oclIsUndefined() then OclUndefined else inn.superClass endif				)
		}
		 		

		
		rule UnresolvedEnumDeclaration{
			from
			   inn : MM!UnresolvedEnumDeclaration (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!EnumDeclaration))
			to
			   out : MM1!UnresolvedEnumDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif,
				enumConstants <- if inn.enumConstants.oclIsUndefined() then OclUndefined else inn.enumConstants endif				)
		}
		 		

		
		rule UnresolvedInterfaceDeclaration{
			from
			   inn : MM!UnresolvedInterfaceDeclaration (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!InterfaceDeclaration))
			to
			   out : MM1!UnresolvedInterfaceDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif				)
		}
		 		

		
		rule UnresolvedLabeledStatement{
			from
			   inn : MM!UnresolvedLabeledStatement (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!LabeledStatement))
			to
			   out : MM1!UnresolvedLabeledStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				usagesInBreakStatements <- if inn.usagesInBreakStatements.oclIsUndefined() then OclUndefined else inn.usagesInBreakStatements endif,
				usagesInContinueStatements <- if inn.usagesInContinueStatements.oclIsUndefined() then OclUndefined else inn.usagesInContinueStatements endif				)
		}
		 		

		
		rule UnresolvedMethodDeclaration{
			from
			   inn : MM!UnresolvedMethodDeclaration (not inn.oclIsTypeOf(MM!MethodDeclaration) and not inn.oclIsTypeOf(MM!UnresolvedMethodDeclaration))
			to
			   out : MM1!UnresolvedMethodDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif,
				parameters <- if inn.parameters.oclIsUndefined() then OclUndefined else inn.parameters endif,
				thrownExceptions <- if inn.thrownExceptions.oclIsUndefined() then OclUndefined else inn.thrownExceptions endif,
				typeParameters <- if inn.typeParameters.oclIsUndefined() then OclUndefined else inn.typeParameters endif,
				-- usagesInDocComments <- if inn.usagesInDocComments.oclIsUndefined() then OclUndefined else inn.usagesInDocComments endif,
				-- usages <- if inn.usages.oclIsUndefined() then OclUndefined else inn.usages endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				returnType <- if inn.returnType.oclIsUndefined() then OclUndefined else inn.returnType endif,
				redefinedMethodDeclaration <- if inn.redefinedMethodDeclaration.oclIsUndefined() then OclUndefined else inn.redefinedMethodDeclaration endif,
				redefinitions <- if inn.redefinitions.oclIsUndefined() then OclUndefined else inn.redefinitions endif				)
		}
		 		

		
		rule UnresolvedSingleVariableDeclaration{
			from
			   inn : MM!UnresolvedSingleVariableDeclaration  (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!SingleVariableDeclaration))
			to
			   out : MM1!UnresolvedSingleVariableDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				initializer <- if inn.initializer.oclIsUndefined() then OclUndefined else inn.initializer endif,
				usageInVariableAccess <- if inn.usageInVariableAccess.oclIsUndefined() then OclUndefined else inn.usageInVariableAccess endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				varargs <- inn.varargs				,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				methodDeclaration <- if inn.methodDeclaration.oclIsUndefined() then OclUndefined else inn.methodDeclaration endif,
				catchClause <- if inn.catchClause.oclIsUndefined() then OclUndefined else inn.catchClause endif,
				enhancedForStatement <- if inn.enhancedForStatement.oclIsUndefined() then OclUndefined else inn.enhancedForStatement endif				)
		}
		 		

		
		rule UnresolvedType{
			from
			   inn : MM!UnresolvedType  (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!Type))
			to
			   out : MM1!UnresolvedType (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				--,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif				
				)
		}
		 		

		
		rule UnresolvedTypeDeclaration{
			from
			   inn : MM!UnresolvedTypeDeclaration (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!AbstractTypeDeclaration))
			to
			   out : MM1!UnresolvedTypeDeclaration (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				abstractTypeDeclaration <- if inn.abstractTypeDeclaration.oclIsUndefined() then OclUndefined else inn.abstractTypeDeclaration endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif,
				anonymousClassDeclarationOwner <- if inn.anonymousClassDeclarationOwner.oclIsUndefined() then OclUndefined else inn.anonymousClassDeclarationOwner endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				bodyDeclarations <- if inn.bodyDeclarations.oclIsUndefined() then OclUndefined else inn.bodyDeclarations endif,
				commentsBeforeBody <- if inn.commentsBeforeBody.oclIsUndefined() then OclUndefined else inn.commentsBeforeBody endif,
				commentsAfterBody <- if inn.commentsAfterBody.oclIsUndefined() then OclUndefined else inn.commentsAfterBody endif,
				package <- if inn.package.oclIsUndefined() then OclUndefined else inn.package endif,
				superInterfaces <- if inn.superInterfaces.oclIsUndefined() then OclUndefined else inn.superInterfaces endif				)
		}
		 		

		
		rule UnresolvedVariableDeclarationFragment{
			from
			   inn : MM!UnresolvedVariableDeclarationFragment (not inn.oclIsTypeOf(MM!UnresolvedItem) and not inn.oclIsTypeOf(MM!VariableDeclarationFragment))
			to
			   out : MM1!UnresolvedVariableDeclarationFragment (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				initializer <- if inn.initializer.oclIsUndefined() then OclUndefined else inn.initializer endif,
				usageInVariableAccess <- if inn.usageInVariableAccess.oclIsUndefined() then OclUndefined else inn.usageInVariableAccess endif,
				variablesContainer <- if inn.variablesContainer.oclIsUndefined() then OclUndefined else inn.variablesContainer endif				)
		}
		 		

		 		

		
		rule VariableDeclarationExpression{
			from
			   inn : MM!VariableDeclarationExpression
			to
			   out : MM1!VariableDeclarationExpression (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				fragments <- if inn.fragments.oclIsUndefined() then OclUndefined else inn.fragments endif,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif				)
		}
		 		

		
		rule VariableDeclarationFragment{
			from
			   inn : MM!VariableDeclarationFragment (not inn.oclIsTypeOf(MM!UnresolvedVariableDeclarationFragment))
			to
			   out : MM1!VariableDeclarationFragment (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				initializer <- if inn.initializer.oclIsUndefined() then OclUndefined else inn.initializer endif,
				usageInVariableAccess <- if inn.usageInVariableAccess.oclIsUndefined() then OclUndefined else inn.usageInVariableAccess endif--,
				--variablesContainer <- if inn.variablesContainer.oclIsUndefined() then OclUndefined else inn.variablesContainer endif				
				)
		}
		 		

		
		rule VariableDeclarationStatement{
			from
			   inn : MM!VariableDeclarationStatement
			to
			   out : MM1!VariableDeclarationStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				type <- if inn.type.oclIsUndefined() then OclUndefined else inn.type endif,
				fragments <- if inn.fragments.oclIsUndefined() then OclUndefined else inn.fragments endif,
				extraArrayDimensions <- inn.extraArrayDimensions				,
				modifier <- if inn.modifier.oclIsUndefined() then OclUndefined else inn.modifier endif,
				annotations <- if inn.annotations.oclIsUndefined() then OclUndefined else inn.annotations endif				)
		}
		 		

		
		rule WildCardType{
			from
			   inn : MM!WildCardType
			to
			   out : MM1!WildCardType (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				name <- inn.name				,
				proxy <- inn.proxy				,
				-- usagesInImports <- if inn.usagesInImports.oclIsUndefined() then OclUndefined else inn.usagesInImports endif,
				-- usagesInTypeAccess <- if inn.usagesInTypeAccess.oclIsUndefined() then OclUndefined else inn.usagesInTypeAccess endif,
				upperBound <- inn.upperBound				,
				bound <- if inn.bound.oclIsUndefined() then OclUndefined else inn.bound endif				)
		}
		 		

		
		rule WhileStatement{
			from
			   inn : MM!WhileStatement
			to
			   out : MM1!WhileStatement (
				comments <- if inn.comments.oclIsUndefined() then OclUndefined else inn.comments endif,
				originalCompilationUnit <- if inn.originalCompilationUnit.oclIsUndefined() then OclUndefined else inn.originalCompilationUnit endif,
				originalClassFile <- if inn.originalClassFile.oclIsUndefined() then OclUndefined else inn.originalClassFile endif,
				expression <- if inn.expression.oclIsUndefined() then OclUndefined else inn.expression endif,
				body <- if inn.body.oclIsUndefined() then OclUndefined else inn.body endif				)
		}