context: // This file has been generated automatically by GrGen (www.grgen.net)
  // Do not modify this file! Any changes will be lost!
  // Generated from "..\..\examples\JavaProgramGraphs-GraBaTs08\JavaProgramGraphs.grg" on Sun Nov 01 11:28:24 CET 2015
  
  using System;
  using System.Collections.Generic;
  using System.IO;
  using GRGEN_LIBGR = de.unika.ipd.grGen.libGr;
  using GRGEN_LGSP = de.unika.ipd.grGen.lgsp;
  using GRGEN_EXPR = de.unika.ipd.grGen.expression;
  using GRGEN_MODEL = de.unika.ipd.grGen.Model_JavaProgramGraphs;
  
  namespace de.unika.ipd.grGen.Model_JavaProgramGraphs
  {
  
  	//
  	// Enums
  	//
  
  	public class Enums
  	{
  	}
  
  	//
  	// Node types
  	//
  
  	public enum NodeTypes { @Node=0, @Package=1, @Classifier=2, @Class=3, @Interface=4, @Variable=5, @Operation=6, @MethodBody=7, @Expression=8, @Access=9, @Update=10, @Call=11, @Instantiation=12, @Operator=13, @Return=14, @Block=15, @Literal=16, @Parameter=17 };
  
  	// *** Node Node ***
  
  
  	public sealed partial class @Node : GRGEN_LGSP.LGSPNode, GRGEN_LIBGR.INode
  	{
  		private static int poolLevel = 0;
  		private static GRGEN_MODEL.@Node[] pool = new GRGEN_MODEL.@Node[10];
  		
  		static @Node() {
  		}
  		
  		public @Node() : base(GRGEN_MODEL.NodeType_Node.typeVar)
  		{
  			// implicit initialization, container creation of Node
  		}
  
  		public static GRGEN_MODEL.NodeType_Node TypeInstance { get { return GRGEN_MODEL.NodeType_Node.typeVar; } }
  
  		public override GRGEN_LIBGR.INode Clone() { return new GRGEN_MODEL.@Node(this); }
  
  		private @Node(GRGEN_MODEL.@Node oldElem) : base(GRGEN_MODEL.NodeType_Node.typeVar)
  		{
  		}
  
  		public override bool AreAttributesEqual(GRGEN_LIBGR.IGraphElement that) {
  			if(!(that is @Node)) return false;
  			@Node that_ = (@Node)that;
  			return true
  			;
  		}
  
  		public static GRGEN_MODEL.@Node CreateNode(GRGEN_LGSP.LGSPGraph graph)
  		{
  			GRGEN_MODEL.@Node node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Node();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Node
  			}
  			graph.AddNode(node);
  			return node;
  		}
  
  		public static GRGEN_MODEL.@Node CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
  		{
  			GRGEN_MODEL.@Node node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Node();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Node
  			}
  			graph.AddNode(node, nodeName);
  			return node;
  		}
  
  		public override void Recycle()
  		{
  			if(poolLevel < 10)
  				pool[poolLevel++] = this;
  		}
  
  		public override object GetAttribute(string attrName)
  		{
  			throw new NullReferenceException(
  				"The node type \"Node\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void SetAttribute(string attrName, object value)
  		{
  			throw new NullReferenceException(
  				"The node type \"Node\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void ResetAllAttributes()
  		{
  			// implicit initialization, container creation of Node
  		}
  
  		public override object ApplyFunctionMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Node does not have the function method " + name + "!");
  			}
  		}
  		public override object[] ApplyProcedureMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Node does not have the procedure method " + name + "!");
  			}
  		}
  	}
  
  	public sealed partial class NodeType_Node : GRGEN_LIBGR.NodeType
  	{
  		public static GRGEN_MODEL.NodeType_Node typeVar = new GRGEN_MODEL.NodeType_Node();
  		public static bool[] isA = new bool[] { true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsA(int typeID) { return isA[typeID]; }
  		public static bool[] isMyType = new bool[] { true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, };
  		public override bool IsMyType(int typeID) { return isMyType[typeID]; }
  		public NodeType_Node() : base((int) NodeTypes.@Node)
  		{
  		}
  		public override string Name { get { return "Node"; } }
  		public override string Package { get { return null; } }
  		public override string PackagePrefixedName { get { return "Node"; } }
  		public override string NodeInterfaceName { get { return "de.unika.ipd.grGen.libGr.INode"; } }
  		public override string NodeClassName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.@Node"; } }
  		public override GRGEN_LIBGR.INode CreateNode()
  		{
  			return new GRGEN_MODEL.@Node();
  		}
  		public override bool IsAbstract { get { return false; } }
  		public override bool IsConst { get { return false; } }
  		public override IEnumerable<KeyValuePair<string, string>> Annotations { get { return annotations; } }
  		public IDictionary<string, string> annotations = new Dictionary<string, string>();
  		public override int NumAttributes { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.AttributeType> AttributeTypes { get { yield break; } }
  		public override GRGEN_LIBGR.AttributeType GetAttributeType(string name) { return null; }
  		public override int NumFunctionMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IFunctionDefinition> FunctionMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IFunctionDefinition GetFunctionMethod(string name) { return null; }
  		public override int NumProcedureMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IProcedureDefinition> ProcedureMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IProcedureDefinition GetProcedureMethod(string name) { return null; }
  		public override bool IsA(GRGEN_LIBGR.GrGenType other)
  		{
  			return (this == other) || isA[other.TypeID];
  		}
  		public override GRGEN_LIBGR.INode CreateNodeWithCopyCommons(GRGEN_LIBGR.INode oldINode)
  		{
  			return new GRGEN_MODEL.@Node();
  		}
  
  	}
  
  	// *** Node Package ***
  
  	public interface IPackage : GRGEN_LIBGR.INode
  	{
  		string @name { get; set; }
  	}
  
  	public sealed partial class @Package : GRGEN_LGSP.LGSPNode, GRGEN_MODEL.IPackage
  	{
  		private static int poolLevel = 0;
  		private static GRGEN_MODEL.@Package[] pool = new GRGEN_MODEL.@Package[10];
  		
  		// explicit initializations of Package for target Package
  		// implicit initializations of Package for target Package
  		static @Package() {
  		}
  		
  		public @Package() : base(GRGEN_MODEL.NodeType_Package.typeVar)
  		{
  			// implicit initialization, container creation of Package
  			// explicit initializations of Package for target Package
  		}
  
  		public static GRGEN_MODEL.NodeType_Package TypeInstance { get { return GRGEN_MODEL.NodeType_Package.typeVar; } }
  
  		public override GRGEN_LIBGR.INode Clone() { return new GRGEN_MODEL.@Package(this); }
  
  		private @Package(GRGEN_MODEL.@Package oldElem) : base(GRGEN_MODEL.NodeType_Package.typeVar)
  		{
  			name_M0no_suXx_h4rD = oldElem.name_M0no_suXx_h4rD;
  		}
  
  		public override bool AreAttributesEqual(GRGEN_LIBGR.IGraphElement that) {
  			if(!(that is @Package)) return false;
  			@Package that_ = (@Package)that;
  			return true
  				&& name_M0no_suXx_h4rD == that_.name_M0no_suXx_h4rD
  			;
  		}
  
  		public static GRGEN_MODEL.@Package CreateNode(GRGEN_LGSP.LGSPGraph graph)
  		{
  			GRGEN_MODEL.@Package node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Package();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Package
  				node.@name = null;
  				// explicit initializations of Package for target Package
  			}
  			graph.AddNode(node);
  			return node;
  		}
  
  		public static GRGEN_MODEL.@Package CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
  		{
  			GRGEN_MODEL.@Package node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Package();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Package
  				node.@name = null;
  				// explicit initializations of Package for target Package
  			}
  			graph.AddNode(node, nodeName);
  			return node;
  		}
  
  		public override void Recycle()
  		{
  			if(poolLevel < 10)
  				pool[poolLevel++] = this;
  		}
  
  
  		private string name_M0no_suXx_h4rD;
  		public string @name
  		{
  			get { return name_M0no_suXx_h4rD; }
  			set { name_M0no_suXx_h4rD = value; }
  		}
  		public override object GetAttribute(string attrName)
  		{
  			switch(attrName)
  			{
  				case "name": return this.@name;
  			}
  			throw new NullReferenceException(
  				"The node type \"Package\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void SetAttribute(string attrName, object value)
  		{
  			switch(attrName)
  			{
  				case "name": this.@name = (string) value; return;
  			}
  			throw new NullReferenceException(
  				"The node type \"Package\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void ResetAllAttributes()
  		{
  			// implicit initialization, container creation of Package
  			this.@name = null;
  			// explicit initializations of Package for target Package
  		}
  
  		public override object ApplyFunctionMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Package does not have the function method " + name + "!");
  			}
  		}
  		public override object[] ApplyProcedureMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Package does not have the procedure method " + name + "!");
  			}
  		}
  	}
  
  	public sealed partial class NodeType_Package : GRGEN_LIBGR.NodeType
  	{
  		public static GRGEN_MODEL.NodeType_Package typeVar = new GRGEN_MODEL.NodeType_Package();
  		public static bool[] isA = new bool[] { true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsA(int typeID) { return isA[typeID]; }
  		public static bool[] isMyType = new bool[] { false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsMyType(int typeID) { return isMyType[typeID]; }
  		public static GRGEN_LIBGR.AttributeType AttributeType_name;
  		public NodeType_Package() : base((int) NodeTypes.@Package)
  		{
  			AttributeType_name = new GRGEN_LIBGR.AttributeType("name", this, GRGEN_LIBGR.AttributeKind.StringAttr, null, null, null, null, null, null, typeof(string));
  		}
  		public override string Name { get { return "Package"; } }
  		public override string Package { get { return null; } }
  		public override string PackagePrefixedName { get { return "Package"; } }
  		public override string NodeInterfaceName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.IPackage"; } }
  		public override string NodeClassName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.@Package"; } }
  		public override GRGEN_LIBGR.INode CreateNode()
  		{
  			return new GRGEN_MODEL.@Package();
  		}
  		public override bool IsAbstract { get { return false; } }
  		public override bool IsConst { get { return false; } }
  		public override IEnumerable<KeyValuePair<string, string>> Annotations { get { return annotations; } }
  		public IDictionary<string, string> annotations = new Dictionary<string, string>();
  		public override int NumAttributes { get { return 1; } }
  		public override IEnumerable<GRGEN_LIBGR.AttributeType> AttributeTypes
  		{
  			get
  			{
  				yield return AttributeType_name;
  			}
  		}
  		public override GRGEN_LIBGR.AttributeType GetAttributeType(string name)
  		{
  			switch(name)
  			{
  				case "name" : return AttributeType_name;
  			}
  			return null;
  		}
  		public override int NumFunctionMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IFunctionDefinition> FunctionMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IFunctionDefinition GetFunctionMethod(string name) { return null; }
  		public override int NumProcedureMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IProcedureDefinition> ProcedureMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IProcedureDefinition GetProcedureMethod(string name) { return null; }
  		public override bool IsA(GRGEN_LIBGR.GrGenType other)
  		{
  			return (this == other) || isA[other.TypeID];
  		}
  		public override GRGEN_LIBGR.INode CreateNodeWithCopyCommons(GRGEN_LIBGR.INode oldINode)
  		{
  			GRGEN_LGSP.LGSPNode oldNode = (GRGEN_LGSP.LGSPNode) oldINode;
  			GRGEN_MODEL.@Package newNode = new GRGEN_MODEL.@Package();
  			switch(oldNode.Type.TypeID)
  			{
  				case (int) GRGEN_MODEL.NodeTypes.@Package:
  					// copy attributes for: Package
  					{
  						GRGEN_MODEL.IPackage old = (GRGEN_MODEL.IPackage) oldNode;
  						newNode.@name = old.@name;
  					}
  					break;
  			}
  			return newNode;
  		}
  
  	}
  
  	public class Comparer_Package_name : Comparer<GRGEN_MODEL.IPackage>
  	{
  		private static GRGEN_MODEL.IPackage nodeBearingAttributeForSearch = new GRGEN_MODEL.@Package();
  		private static Comparer_Package_name thisComparer = new Comparer_Package_name();
  		public override int Compare(GRGEN_MODEL.IPackage a, GRGEN_MODEL.IPackage b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@name, b.@name);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IPackage> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IPackage> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IPackage> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IPackage> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IPackage> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@name = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IPackage> ArrayOrderAscendingBy(List<GRGEN_MODEL.IPackage> list)
  		{
  			List<GRGEN_MODEL.IPackage> newList = new List<GRGEN_MODEL.IPackage>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	// *** Node Classifier ***
  
  	public interface IClassifier : GRGEN_LIBGR.INode
  	{
  		string @name { get; set; }
  		string @visibility { get; set; }
  		bool @isAbstract { get; set; }
  	}
  
  	public sealed partial class @Classifier : GRGEN_LGSP.LGSPNode, GRGEN_MODEL.IClassifier
  	{
  		private static int poolLevel = 0;
  		private static GRGEN_MODEL.@Classifier[] pool = new GRGEN_MODEL.@Classifier[10];
  		
  		// explicit initializations of Classifier for target Classifier
  		// implicit initializations of Classifier for target Classifier
  		static @Classifier() {
  		}
  		
  		public @Classifier() : base(GRGEN_MODEL.NodeType_Classifier.typeVar)
  		{
  			// implicit initialization, container creation of Classifier
  			// explicit initializations of Classifier for target Classifier
  		}
  
  		public static GRGEN_MODEL.NodeType_Classifier TypeInstance { get { return GRGEN_MODEL.NodeType_Classifier.typeVar; } }
  
  		public override GRGEN_LIBGR.INode Clone() { return new GRGEN_MODEL.@Classifier(this); }
  
  		private @Classifier(GRGEN_MODEL.@Classifier oldElem) : base(GRGEN_MODEL.NodeType_Classifier.typeVar)
  		{
  			name_M0no_suXx_h4rD = oldElem.name_M0no_suXx_h4rD;
  			visibility_M0no_suXx_h4rD = oldElem.visibility_M0no_suXx_h4rD;
  			isAbstract_M0no_suXx_h4rD = oldElem.isAbstract_M0no_suXx_h4rD;
  		}
  
  		public override bool AreAttributesEqual(GRGEN_LIBGR.IGraphElement that) {
  			if(!(that is @Classifier)) return false;
  			@Classifier that_ = (@Classifier)that;
  			return true
  				&& name_M0no_suXx_h4rD == that_.name_M0no_suXx_h4rD
  				&& visibility_M0no_suXx_h4rD == that_.visibility_M0no_suXx_h4rD
  				&& isAbstract_M0no_suXx_h4rD == that_.isAbstract_M0no_suXx_h4rD
  			;
  		}
  
  		public static GRGEN_MODEL.@Classifier CreateNode(GRGEN_LGSP.LGSPGraph graph)
  		{
  			GRGEN_MODEL.@Classifier node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Classifier();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Classifier
  				node.@name = null;
  				node.@visibility = null;
  				node.@isAbstract = false;
  				// explicit initializations of Classifier for target Classifier
  			}
  			graph.AddNode(node);
  			return node;
  		}
  
  		public static GRGEN_MODEL.@Classifier CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
  		{
  			GRGEN_MODEL.@Classifier node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Classifier();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Classifier
  				node.@name = null;
  				node.@visibility = null;
  				node.@isAbstract = false;
  				// explicit initializations of Classifier for target Classifier
  			}
  			graph.AddNode(node, nodeName);
  			return node;
  		}
  
  		public override void Recycle()
  		{
  			if(poolLevel < 10)
  				pool[poolLevel++] = this;
  		}
  
  
  		private string name_M0no_suXx_h4rD;
  		public string @name
  		{
  			get { return name_M0no_suXx_h4rD; }
  			set { name_M0no_suXx_h4rD = value; }
  		}
  
  		private string visibility_M0no_suXx_h4rD;
  		public string @visibility
  		{
  			get { return visibility_M0no_suXx_h4rD; }
  			set { visibility_M0no_suXx_h4rD = value; }
  		}
  
  		private bool isAbstract_M0no_suXx_h4rD;
  		public bool @isAbstract
  		{
  			get { return isAbstract_M0no_suXx_h4rD; }
  			set { isAbstract_M0no_suXx_h4rD = value; }
  		}
  		public override object GetAttribute(string attrName)
  		{
  			switch(attrName)
  			{
  				case "name": return this.@name;
  				case "visibility": return this.@visibility;
  				case "isAbstract": return this.@isAbstract;
  			}
  			throw new NullReferenceException(
  				"The node type \"Classifier\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void SetAttribute(string attrName, object value)
  		{
  			switch(attrName)
  			{
  				case "name": this.@name = (string) value; return;
  				case "visibility": this.@visibility = (string) value; return;
  				case "isAbstract": this.@isAbstract = (bool) value; return;
  			}
  			throw new NullReferenceException(
  				"The node type \"Classifier\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void ResetAllAttributes()
  		{
  			// implicit initialization, container creation of Classifier
  			this.@name = null;
  			this.@visibility = null;
  			this.@isAbstract = false;
  			// explicit initializations of Classifier for target Classifier
  		}
  
  		public override object ApplyFunctionMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Classifier does not have the function method " + name + "!");
  			}
  		}
  		public override object[] ApplyProcedureMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Classifier does not have the procedure method " + name + "!");
  			}
  		}
  	}
  
  	public sealed partial class NodeType_Classifier : GRGEN_LIBGR.NodeType
  	{
  		public static GRGEN_MODEL.NodeType_Classifier typeVar = new GRGEN_MODEL.NodeType_Classifier();
  		public static bool[] isA = new bool[] { true, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsA(int typeID) { return isA[typeID]; }
  		public static bool[] isMyType = new bool[] { false, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsMyType(int typeID) { return isMyType[typeID]; }
  		public static GRGEN_LIBGR.AttributeType AttributeType_name;
  		public static GRGEN_LIBGR.AttributeType AttributeType_visibility;
  		public static GRGEN_LIBGR.AttributeType AttributeType_isAbstract;
  		public NodeType_Classifier() : base((int) NodeTypes.@Classifier)
  		{
  			AttributeType_name = new GRGEN_LIBGR.AttributeType("name", this, GRGEN_LIBGR.AttributeKind.StringAttr, null, null, null, null, null, null, typeof(string));
  			AttributeType_visibility = new GRGEN_LIBGR.AttributeType("visibility", this, GRGEN_LIBGR.AttributeKind.StringAttr, null, null, null, null, null, null, typeof(string));
  			AttributeType_isAbstract = new GRGEN_LIBGR.AttributeType("isAbstract", this, GRGEN_LIBGR.AttributeKind.BooleanAttr, null, null, null, null, null, null, typeof(bool));
  		}
  		public override string Name { get { return "Classifier"; } }
  		public override string Package { get { return null; } }
  		public override string PackagePrefixedName { get { return "Classifier"; } }
  		public override string NodeInterfaceName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.IClassifier"; } }
  		public override string NodeClassName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.@Classifier"; } }
  		public override GRGEN_LIBGR.INode CreateNode()
  		{
  			return new GRGEN_MODEL.@Classifier();
  		}
  		public override bool IsAbstract { get { return false; } }
  		public override bool IsConst { get { return false; } }
  		public override IEnumerable<KeyValuePair<string, string>> Annotations { get { return annotations; } }
  		public IDictionary<string, string> annotations = new Dictionary<string, string>();
  		public override int NumAttributes { get { return 3; } }
  		public override IEnumerable<GRGEN_LIBGR.AttributeType> AttributeTypes
  		{
  			get
  			{
  				yield return AttributeType_name;
  				yield return AttributeType_visibility;
  				yield return AttributeType_isAbstract;
  			}
  		}
  		public override GRGEN_LIBGR.AttributeType GetAttributeType(string name)
  		{
  			switch(name)
  			{
  				case "name" : return AttributeType_name;
  				case "visibility" : return AttributeType_visibility;
  				case "isAbstract" : return AttributeType_isAbstract;
  			}
  			return null;
  		}
  		public override int NumFunctionMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IFunctionDefinition> FunctionMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IFunctionDefinition GetFunctionMethod(string name) { return null; }
  		public override int NumProcedureMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IProcedureDefinition> ProcedureMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IProcedureDefinition GetProcedureMethod(string name) { return null; }
  		public override bool IsA(GRGEN_LIBGR.GrGenType other)
  		{
  			return (this == other) || isA[other.TypeID];
  		}
  		public override GRGEN_LIBGR.INode CreateNodeWithCopyCommons(GRGEN_LIBGR.INode oldINode)
  		{
  			GRGEN_LGSP.LGSPNode oldNode = (GRGEN_LGSP.LGSPNode) oldINode;
  			GRGEN_MODEL.@Classifier newNode = new GRGEN_MODEL.@Classifier();
  			switch(oldNode.Type.TypeID)
  			{
  				case (int) GRGEN_MODEL.NodeTypes.@Classifier:
  				case (int) GRGEN_MODEL.NodeTypes.@Class:
  				case (int) GRGEN_MODEL.NodeTypes.@Interface:
  					// copy attributes for: Classifier
  					{
  						GRGEN_MODEL.IClassifier old = (GRGEN_MODEL.IClassifier) oldNode;
  						newNode.@name = old.@name;
  						newNode.@visibility = old.@visibility;
  						newNode.@isAbstract = old.@isAbstract;
  					}
  					break;
  			}
  			return newNode;
  		}
  
  	}
  
  	public class Comparer_Classifier_name : Comparer<GRGEN_MODEL.IClassifier>
  	{
  		private static GRGEN_MODEL.IClassifier nodeBearingAttributeForSearch = new GRGEN_MODEL.@Classifier();
  		private static Comparer_Classifier_name thisComparer = new Comparer_Classifier_name();
  		public override int Compare(GRGEN_MODEL.IClassifier a, GRGEN_MODEL.IClassifier b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@name, b.@name);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClassifier> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@name = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClassifier> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClassifier> list)
  		{
  			List<GRGEN_MODEL.IClassifier> newList = new List<GRGEN_MODEL.IClassifier>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Classifier_visibility : Comparer<GRGEN_MODEL.IClassifier>
  	{
  		private static GRGEN_MODEL.IClassifier nodeBearingAttributeForSearch = new GRGEN_MODEL.@Classifier();
  		private static Comparer_Classifier_visibility thisComparer = new Comparer_Classifier_visibility();
  		public override int Compare(GRGEN_MODEL.IClassifier a, GRGEN_MODEL.IClassifier b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@visibility, b.@visibility);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClassifier> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClassifier> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@visibility = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClassifier> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClassifier> list)
  		{
  			List<GRGEN_MODEL.IClassifier> newList = new List<GRGEN_MODEL.IClassifier>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Classifier_isAbstract : Comparer<GRGEN_MODEL.IClassifier>
  	{
  		private static GRGEN_MODEL.IClassifier nodeBearingAttributeForSearch = new GRGEN_MODEL.@Classifier();
  		private static Comparer_Classifier_isAbstract thisComparer = new Comparer_Classifier_isAbstract();
  		public override int Compare(GRGEN_MODEL.IClassifier a, GRGEN_MODEL.IClassifier b)
  		{
  			return a.@isAbstract.CompareTo(b.@isAbstract);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClassifier> list, bool entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClassifier> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClassifier> list, bool entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClassifier> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClassifier> list, bool entry)
  		{
  			nodeBearingAttributeForSearch.@isAbstract = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClassifier> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClassifier> list)
  		{
  			List<GRGEN_MODEL.IClassifier> newList = new List<GRGEN_MODEL.IClassifier>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	// *** Node Class ***
  
  	public interface IClass : IClassifier
  	{
  		bool @isFinal { get; set; }
  	}
  
  	public sealed partial class @Class : GRGEN_LGSP.LGSPNode, GRGEN_MODEL.IClass
  	{
  		private static int poolLevel = 0;
  		private static GRGEN_MODEL.@Class[] pool = new GRGEN_MODEL.@Class[10];
  		
  		// explicit initializations of Classifier for target Class
  		// implicit initializations of Classifier for target Class
  		// explicit initializations of Class for target Class
  		// implicit initializations of Class for target Class
  		static @Class() {
  		}
  		
  		public @Class() : base(GRGEN_MODEL.NodeType_Class.typeVar)
  		{
  			// implicit initialization, container creation of Class
  			// explicit initializations of Classifier for target Class
  			// explicit initializations of Class for target Class
  		}
  
  		public static GRGEN_MODEL.NodeType_Class TypeInstance { get { return GRGEN_MODEL.NodeType_Class.typeVar; } }
  
  		public override GRGEN_LIBGR.INode Clone() { return new GRGEN_MODEL.@Class(this); }
  
  		private @Class(GRGEN_MODEL.@Class oldElem) : base(GRGEN_MODEL.NodeType_Class.typeVar)
  		{
  			name_M0no_suXx_h4rD = oldElem.name_M0no_suXx_h4rD;
  			visibility_M0no_suXx_h4rD = oldElem.visibility_M0no_suXx_h4rD;
  			isAbstract_M0no_suXx_h4rD = oldElem.isAbstract_M0no_suXx_h4rD;
  			isFinal_M0no_suXx_h4rD = oldElem.isFinal_M0no_suXx_h4rD;
  		}
  
  		public override bool AreAttributesEqual(GRGEN_LIBGR.IGraphElement that) {
  			if(!(that is @Class)) return false;
  			@Class that_ = (@Class)that;
  			return true
  				&& name_M0no_suXx_h4rD == that_.name_M0no_suXx_h4rD
  				&& visibility_M0no_suXx_h4rD == that_.visibility_M0no_suXx_h4rD
  				&& isAbstract_M0no_suXx_h4rD == that_.isAbstract_M0no_suXx_h4rD
  				&& isFinal_M0no_suXx_h4rD == that_.isFinal_M0no_suXx_h4rD
  			;
  		}
  
  		public static GRGEN_MODEL.@Class CreateNode(GRGEN_LGSP.LGSPGraph graph)
  		{
  			GRGEN_MODEL.@Class node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Class();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Class
  				node.@name = null;
  				node.@visibility = null;
  				node.@isAbstract = false;
  				node.@isFinal = false;
  				// explicit initializations of Classifier for target Class
  				// explicit initializations of Class for target Class
  			}
  			graph.AddNode(node);
  			return node;
  		}
  
  		public static GRGEN_MODEL.@Class CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
  		{
  			GRGEN_MODEL.@Class node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Class();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Class
  				node.@name = null;
  				node.@visibility = null;
  				node.@isAbstract = false;
  				node.@isFinal = false;
  				// explicit initializations of Classifier for target Class
  				// explicit initializations of Class for target Class
  			}
  			graph.AddNode(node, nodeName);
  			return node;
  		}
  
  		public override void Recycle()
  		{
  			if(poolLevel < 10)
  				pool[poolLevel++] = this;
  		}
  
  
  		private string name_M0no_suXx_h4rD;
  		public string @name
  		{
  			get { return name_M0no_suXx_h4rD; }
  			set { name_M0no_suXx_h4rD = value; }
  		}
  
  		private string visibility_M0no_suXx_h4rD;
  		public string @visibility
  		{
  			get { return visibility_M0no_suXx_h4rD; }
  			set { visibility_M0no_suXx_h4rD = value; }
  		}
  
  		private bool isAbstract_M0no_suXx_h4rD;
  		public bool @isAbstract
  		{
  			get { return isAbstract_M0no_suXx_h4rD; }
  			set { isAbstract_M0no_suXx_h4rD = value; }
  		}
  
  		private bool isFinal_M0no_suXx_h4rD;
  		public bool @isFinal
  		{
  			get { return isFinal_M0no_suXx_h4rD; }
  			set { isFinal_M0no_suXx_h4rD = value; }
  		}
  		public override object GetAttribute(string attrName)
  		{
  			switch(attrName)
  			{
  				case "name": return this.@name;
  				case "visibility": return this.@visibility;
  				case "isAbstract": return this.@isAbstract;
  				case "isFinal": return this.@isFinal;
  			}
  			throw new NullReferenceException(
  				"The node type \"Class\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void SetAttribute(string attrName, object value)
  		{
  			switch(attrName)
  			{
  				case "name": this.@name = (string) value; return;
  				case "visibility": this.@visibility = (string) value; return;
  				case "isAbstract": this.@isAbstract = (bool) value; return;
  				case "isFinal": this.@isFinal = (bool) value; return;
  			}
  			throw new NullReferenceException(
  				"The node type \"Class\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void ResetAllAttributes()
  		{
  			// implicit initialization, container creation of Class
  			this.@name = null;
  			this.@visibility = null;
  			this.@isAbstract = false;
  			this.@isFinal = false;
  			// explicit initializations of Classifier for target Class
  			// explicit initializations of Class for target Class
  		}
  
  		public override object ApplyFunctionMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Class does not have the function method " + name + "!");
  			}
  		}
  		public override object[] ApplyProcedureMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Class does not have the procedure method " + name + "!");
  			}
  		}
  	}
  
  	public sealed partial class NodeType_Class : GRGEN_LIBGR.NodeType
  	{
  		public static GRGEN_MODEL.NodeType_Class typeVar = new GRGEN_MODEL.NodeType_Class();
  		public static bool[] isA = new bool[] { true, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsA(int typeID) { return isA[typeID]; }
  		public static bool[] isMyType = new bool[] { false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsMyType(int typeID) { return isMyType[typeID]; }
  		public static GRGEN_LIBGR.AttributeType AttributeType_isFinal;
  		public NodeType_Class() : base((int) NodeTypes.@Class)
  		{
  			AttributeType_isFinal = new GRGEN_LIBGR.AttributeType("isFinal", this, GRGEN_LIBGR.AttributeKind.BooleanAttr, null, null, null, null, null, null, typeof(bool));
  		}
  		public override string Name { get { return "Class"; } }
  		public override string Package { get { return null; } }
  		public override string PackagePrefixedName { get { return "Class"; } }
  		public override string NodeInterfaceName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.IClass"; } }
  		public override string NodeClassName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.@Class"; } }
  		public override GRGEN_LIBGR.INode CreateNode()
  		{
  			return new GRGEN_MODEL.@Class();
  		}
  		public override bool IsAbstract { get { return false; } }
  		public override bool IsConst { get { return false; } }
  		public override IEnumerable<KeyValuePair<string, string>> Annotations { get { return annotations; } }
  		public IDictionary<string, string> annotations = new Dictionary<string, string>();
  		public override int NumAttributes { get { return 4; } }
  		public override IEnumerable<GRGEN_LIBGR.AttributeType> AttributeTypes
  		{
  			get
  			{
  				yield return GRGEN_MODEL.NodeType_Classifier.AttributeType_name;
  				yield return GRGEN_MODEL.NodeType_Classifier.AttributeType_visibility;
  				yield return GRGEN_MODEL.NodeType_Classifier.AttributeType_isAbstract;
  				yield return AttributeType_isFinal;
  			}
  		}
  		public override GRGEN_LIBGR.AttributeType GetAttributeType(string name)
  		{
  			switch(name)
  			{
  				case "name" : return GRGEN_MODEL.NodeType_Classifier.AttributeType_name;
  				case "visibility" : return GRGEN_MODEL.NodeType_Classifier.AttributeType_visibility;
  				case "isAbstract" : return GRGEN_MODEL.NodeType_Classifier.AttributeType_isAbstract;
  				case "isFinal" : return AttributeType_isFinal;
  			}
  			return null;
  		}
  		public override int NumFunctionMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IFunctionDefinition> FunctionMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IFunctionDefinition GetFunctionMethod(string name) { return null; }
  		public override int NumProcedureMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IProcedureDefinition> ProcedureMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IProcedureDefinition GetProcedureMethod(string name) { return null; }
  		public override bool IsA(GRGEN_LIBGR.GrGenType other)
  		{
  			return (this == other) || isA[other.TypeID];
  		}
  		public override GRGEN_LIBGR.INode CreateNodeWithCopyCommons(GRGEN_LIBGR.INode oldINode)
  		{
  			GRGEN_LGSP.LGSPNode oldNode = (GRGEN_LGSP.LGSPNode) oldINode;
  			GRGEN_MODEL.@Class newNode = new GRGEN_MODEL.@Class();
  			switch(oldNode.Type.TypeID)
  			{
  				case (int) GRGEN_MODEL.NodeTypes.@Classifier:
  				case (int) GRGEN_MODEL.NodeTypes.@Interface:
  					// copy attributes for: Classifier
  					{
  						GRGEN_MODEL.IClassifier old = (GRGEN_MODEL.IClassifier) oldNode;
  						newNode.@name = old.@name;
  						newNode.@visibility = old.@visibility;
  						newNode.@isAbstract = old.@isAbstract;
  					}
  					break;
  				case (int) GRGEN_MODEL.NodeTypes.@Class:
  					// copy attributes for: Class
  					{
  						GRGEN_MODEL.IClass old = (GRGEN_MODEL.IClass) oldNode;
  						newNode.@name = old.@name;
  						newNode.@visibility = old.@visibility;
  						newNode.@isAbstract = old.@isAbstract;
  						newNode.@isFinal = old.@isFinal;
  					}
  					break;
  			}
  			return newNode;
  		}
  
  	}
  
  	public class Comparer_Class_name : Comparer<GRGEN_MODEL.IClass>
  	{
  		private static GRGEN_MODEL.IClass nodeBearingAttributeForSearch = new GRGEN_MODEL.@Class();
  		private static Comparer_Class_name thisComparer = new Comparer_Class_name();
  		public override int Compare(GRGEN_MODEL.IClass a, GRGEN_MODEL.IClass b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@name, b.@name);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClass> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@name = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClass> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClass> list)
  		{
  			List<GRGEN_MODEL.IClass> newList = new List<GRGEN_MODEL.IClass>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Class_visibility : Comparer<GRGEN_MODEL.IClass>
  	{
  		private static GRGEN_MODEL.IClass nodeBearingAttributeForSearch = new GRGEN_MODEL.@Class();
  		private static Comparer_Class_visibility thisComparer = new Comparer_Class_visibility();
  		public override int Compare(GRGEN_MODEL.IClass a, GRGEN_MODEL.IClass b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@visibility, b.@visibility);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClass> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@visibility = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClass> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClass> list)
  		{
  			List<GRGEN_MODEL.IClass> newList = new List<GRGEN_MODEL.IClass>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Class_isAbstract : Comparer<GRGEN_MODEL.IClass>
  	{
  		private static GRGEN_MODEL.IClass nodeBearingAttributeForSearch = new GRGEN_MODEL.@Class();
  		private static Comparer_Class_isAbstract thisComparer = new Comparer_Class_isAbstract();
  		public override int Compare(GRGEN_MODEL.IClass a, GRGEN_MODEL.IClass b)
  		{
  			return a.@isAbstract.CompareTo(b.@isAbstract);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClass> list, bool entry)
  		{
  			nodeBearingAttributeForSearch.@isAbstract = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClass> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClass> list)
  		{
  			List<GRGEN_MODEL.IClass> newList = new List<GRGEN_MODEL.IClass>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Class_isFinal : Comparer<GRGEN_MODEL.IClass>
  	{
  		private static GRGEN_MODEL.IClass nodeBearingAttributeForSearch = new GRGEN_MODEL.@Class();
  		private static Comparer_Class_isFinal thisComparer = new Comparer_Class_isFinal();
  		public override int Compare(GRGEN_MODEL.IClass a, GRGEN_MODEL.IClass b)
  		{
  			return a.@isFinal.CompareTo(b.@isFinal);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@isFinal.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@isFinal.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@isFinal.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IClass> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@isFinal.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IClass> list, bool entry)
  		{
  			nodeBearingAttributeForSearch.@isFinal = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IClass> ArrayOrderAscendingBy(List<GRGEN_MODEL.IClass> list)
  		{
  			List<GRGEN_MODEL.IClass> newList = new List<GRGEN_MODEL.IClass>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	// *** Node Interface ***
  
  	public interface IInterface : IClassifier
  	{
  	}
  
  	public sealed partial class @Interface : GRGEN_LGSP.LGSPNode, GRGEN_MODEL.IInterface
  	{
  		private static int poolLevel = 0;
  		private static GRGEN_MODEL.@Interface[] pool = new GRGEN_MODEL.@Interface[10];
  		
  		// explicit initializations of Classifier for target Interface
  		// implicit initializations of Classifier for target Interface
  		// explicit initializations of Interface for target Interface
  		// implicit initializations of Interface for target Interface
  		static @Interface() {
  		}
  		
  		public @Interface() : base(GRGEN_MODEL.NodeType_Interface.typeVar)
  		{
  			// implicit initialization, container creation of Interface
  			// explicit initializations of Classifier for target Interface
  			// explicit initializations of Interface for target Interface
  		}
  
  		public static GRGEN_MODEL.NodeType_Interface TypeInstance { get { return GRGEN_MODEL.NodeType_Interface.typeVar; } }
  
  		public override GRGEN_LIBGR.INode Clone() { return new GRGEN_MODEL.@Interface(this); }
  
  		private @Interface(GRGEN_MODEL.@Interface oldElem) : base(GRGEN_MODEL.NodeType_Interface.typeVar)
  		{
  			name_M0no_suXx_h4rD = oldElem.name_M0no_suXx_h4rD;
  			visibility_M0no_suXx_h4rD = oldElem.visibility_M0no_suXx_h4rD;
  			isAbstract_M0no_suXx_h4rD = oldElem.isAbstract_M0no_suXx_h4rD;
  		}
  
  		public override bool AreAttributesEqual(GRGEN_LIBGR.IGraphElement that) {
  			if(!(that is @Interface)) return false;
  			@Interface that_ = (@Interface)that;
  			return true
  				&& name_M0no_suXx_h4rD == that_.name_M0no_suXx_h4rD
  				&& visibility_M0no_suXx_h4rD == that_.visibility_M0no_suXx_h4rD
  				&& isAbstract_M0no_suXx_h4rD == that_.isAbstract_M0no_suXx_h4rD
  			;
  		}
  
  		public static GRGEN_MODEL.@Interface CreateNode(GRGEN_LGSP.LGSPGraph graph)
  		{
  			GRGEN_MODEL.@Interface node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Interface();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Interface
  				node.@name = null;
  				node.@visibility = null;
  				node.@isAbstract = false;
  				// explicit initializations of Classifier for target Interface
  				// explicit initializations of Interface for target Interface
  			}
  			graph.AddNode(node);
  			return node;
  		}
  
  		public static GRGEN_MODEL.@Interface CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
  		{
  			GRGEN_MODEL.@Interface node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Interface();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Interface
  				node.@name = null;
  				node.@visibility = null;
  				node.@isAbstract = false;
  				// explicit initializations of Classifier for target Interface
  				// explicit initializations of Interface for target Interface
  			}
  			graph.AddNode(node, nodeName);
  			return node;
  		}
  
  		public override void Recycle()
  		{
  			if(poolLevel < 10)
  				pool[poolLevel++] = this;
  		}
  
  
  		private string name_M0no_suXx_h4rD;
  		public string @name
  		{
  			get { return name_M0no_suXx_h4rD; }
  			set { name_M0no_suXx_h4rD = value; }
  		}
  
  		private string visibility_M0no_suXx_h4rD;
  		public string @visibility
  		{
  			get { return visibility_M0no_suXx_h4rD; }
  			set { visibility_M0no_suXx_h4rD = value; }
  		}
  
  		private bool isAbstract_M0no_suXx_h4rD;
  		public bool @isAbstract
  		{
  			get { return isAbstract_M0no_suXx_h4rD; }
  			set { isAbstract_M0no_suXx_h4rD = value; }
  		}
  		public override object GetAttribute(string attrName)
  		{
  			switch(attrName)
  			{
  				case "name": return this.@name;
  				case "visibility": return this.@visibility;
  				case "isAbstract": return this.@isAbstract;
  			}
  			throw new NullReferenceException(
  				"The node type \"Interface\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void SetAttribute(string attrName, object value)
  		{
  			switch(attrName)
  			{
  				case "name": this.@name = (string) value; return;
  				case "visibility": this.@visibility = (string) value; return;
  				case "isAbstract": this.@isAbstract = (bool) value; return;
  			}
  			throw new NullReferenceException(
  				"The node type \"Interface\" does not have the attribute \"" + attrName + "\"!");
  		}
  		public override void ResetAllAttributes()
  		{
  			// implicit initialization, container creation of Interface
  			this.@name = null;
  			this.@visibility = null;
  			this.@isAbstract = false;
  			// explicit initializations of Classifier for target Interface
  			// explicit initializations of Interface for target Interface
  		}
  
  		public override object ApplyFunctionMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Interface does not have the function method " + name + "!");
  			}
  		}
  		public override object[] ApplyProcedureMethod(GRGEN_LIBGR.IActionExecutionEnvironment actionEnv, GRGEN_LIBGR.IGraph graph, string name, object[] arguments)
  		{
  			switch(name)
  			{
  				default: throw new NullReferenceException("Interface does not have the procedure method " + name + "!");
  			}
  		}
  	}
  
  	public sealed partial class NodeType_Interface : GRGEN_LIBGR.NodeType
  	{
  		public static GRGEN_MODEL.NodeType_Interface typeVar = new GRGEN_MODEL.NodeType_Interface();
  		public static bool[] isA = new bool[] { true, false, true, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsA(int typeID) { return isA[typeID]; }
  		public static bool[] isMyType = new bool[] { false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, };
  		public override bool IsMyType(int typeID) { return isMyType[typeID]; }
  		public NodeType_Interface() : base((int) NodeTypes.@Interface)
  		{
  		}
  		public override string Name { get { return "Interface"; } }
  		public override string Package { get { return null; } }
  		public override string PackagePrefixedName { get { return "Interface"; } }
  		public override string NodeInterfaceName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.IInterface"; } }
  		public override string NodeClassName { get { return "de.unika.ipd.grGen.Model_JavaProgramGraphs.@Interface"; } }
  		public override GRGEN_LIBGR.INode CreateNode()
  		{
  			return new GRGEN_MODEL.@Interface();
  		}
  		public override bool IsAbstract { get { return false; } }
  		public override bool IsConst { get { return false; } }
  		public override IEnumerable<KeyValuePair<string, string>> Annotations { get { return annotations; } }
  		public IDictionary<string, string> annotations = new Dictionary<string, string>();
  		public override int NumAttributes { get { return 3; } }
  		public override IEnumerable<GRGEN_LIBGR.AttributeType> AttributeTypes
  		{
  			get
  			{
  				yield return GRGEN_MODEL.NodeType_Classifier.AttributeType_name;
  				yield return GRGEN_MODEL.NodeType_Classifier.AttributeType_visibility;
  				yield return GRGEN_MODEL.NodeType_Classifier.AttributeType_isAbstract;
  			}
  		}
  		public override GRGEN_LIBGR.AttributeType GetAttributeType(string name)
  		{
  			switch(name)
  			{
  				case "name" : return GRGEN_MODEL.NodeType_Classifier.AttributeType_name;
  				case "visibility" : return GRGEN_MODEL.NodeType_Classifier.AttributeType_visibility;
  				case "isAbstract" : return GRGEN_MODEL.NodeType_Classifier.AttributeType_isAbstract;
  			}
  			return null;
  		}
  		public override int NumFunctionMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IFunctionDefinition> FunctionMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IFunctionDefinition GetFunctionMethod(string name) { return null; }
  		public override int NumProcedureMethods { get { return 0; } }
  		public override IEnumerable<GRGEN_LIBGR.IProcedureDefinition> ProcedureMethods { get { yield break; } }
  		public override GRGEN_LIBGR.IProcedureDefinition GetProcedureMethod(string name) { return null; }
  		public override bool IsA(GRGEN_LIBGR.GrGenType other)
  		{
  			return (this == other) || isA[other.TypeID];
  		}
  		public override GRGEN_LIBGR.INode CreateNodeWithCopyCommons(GRGEN_LIBGR.INode oldINode)
  		{
  			GRGEN_LGSP.LGSPNode oldNode = (GRGEN_LGSP.LGSPNode) oldINode;
  			GRGEN_MODEL.@Interface newNode = new GRGEN_MODEL.@Interface();
  			switch(oldNode.Type.TypeID)
  			{
  				case (int) GRGEN_MODEL.NodeTypes.@Classifier:
  				case (int) GRGEN_MODEL.NodeTypes.@Class:
  					// copy attributes for: Classifier
  					{
  						GRGEN_MODEL.IClassifier old = (GRGEN_MODEL.IClassifier) oldNode;
  						newNode.@name = old.@name;
  						newNode.@visibility = old.@visibility;
  						newNode.@isAbstract = old.@isAbstract;
  					}
  					break;
  				case (int) GRGEN_MODEL.NodeTypes.@Interface:
  					// copy attributes for: Interface
  					{
  						GRGEN_MODEL.IInterface old = (GRGEN_MODEL.IInterface) oldNode;
  						newNode.@name = old.@name;
  						newNode.@visibility = old.@visibility;
  						newNode.@isAbstract = old.@isAbstract;
  					}
  					break;
  			}
  			return newNode;
  		}
  
  	}
  
  	public class Comparer_Interface_name : Comparer<GRGEN_MODEL.IInterface>
  	{
  		private static GRGEN_MODEL.IInterface nodeBearingAttributeForSearch = new GRGEN_MODEL.@Interface();
  		private static Comparer_Interface_name thisComparer = new Comparer_Interface_name();
  		public override int Compare(GRGEN_MODEL.IInterface a, GRGEN_MODEL.IInterface b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@name, b.@name);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@name.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IInterface> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@name = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IInterface> ArrayOrderAscendingBy(List<GRGEN_MODEL.IInterface> list)
  		{
  			List<GRGEN_MODEL.IInterface> newList = new List<GRGEN_MODEL.IInterface>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Interface_visibility : Comparer<GRGEN_MODEL.IInterface>
  	{
  		private static GRGEN_MODEL.IInterface nodeBearingAttributeForSearch = new GRGEN_MODEL.@Interface();
  		private static Comparer_Interface_visibility thisComparer = new Comparer_Interface_visibility();
  		public override int Compare(GRGEN_MODEL.IInterface a, GRGEN_MODEL.IInterface b)
  		{
  			return StringComparer.InvariantCulture.Compare(a.@visibility, b.@visibility);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IInterface> list, string entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@visibility.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IInterface> list, string entry)
  		{
  			nodeBearingAttributeForSearch.@visibility = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IInterface> ArrayOrderAscendingBy(List<GRGEN_MODEL.IInterface> list)
  		{
  			List<GRGEN_MODEL.IInterface> newList = new List<GRGEN_MODEL.IInterface>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	public class Comparer_Interface_isAbstract : Comparer<GRGEN_MODEL.IInterface>
  	{
  		private static GRGEN_MODEL.IInterface nodeBearingAttributeForSearch = new GRGEN_MODEL.@Interface();
  		private static Comparer_Interface_isAbstract thisComparer = new Comparer_Interface_isAbstract();
  		public override int Compare(GRGEN_MODEL.IInterface a, GRGEN_MODEL.IInterface b)
  		{
  			return a.@isAbstract.CompareTo(b.@isAbstract);
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IInterface> list, bool entry)
  		{
  			for(int i = 0; i < list.Count; ++i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfBy(IList<GRGEN_MODEL.IInterface> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i < list.Count; ++i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IInterface> list, bool entry)
  		{
  			for(int i = list.Count - 1; i >= 0; --i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int LastIndexOfBy(IList<GRGEN_MODEL.IInterface> list, bool entry, int startIndex)
  		{
  			for(int i = startIndex; i >= 0; --i)
  				if(list[i].@isAbstract.Equals(entry))
  					return i;
  			return -1;
  		}
  		public static int IndexOfOrderedBy(List<GRGEN_MODEL.IInterface> list, bool entry)
  		{
  			nodeBearingAttributeForSearch.@isAbstract = entry;
  			return list.BinarySearch(nodeBearingAttributeForSearch, thisComparer);
  		}
  		public static List<GRGEN_MODEL.IInterface> ArrayOrderAscendingBy(List<GRGEN_MODEL.IInterface> list)
  		{
  			List<GRGEN_MODEL.IInterface> newList = new List<GRGEN_MODEL.IInterface>(list);
  			newList.Sort(thisComparer);
  			return newList;
  		}
  	}
  
  
  	// *** Node Variable ***
  
  	public interface IVariable : GRGEN_LIBGR.INode
  	{
  		string @name { get; set; }
  		string @visibility { get; set; }
  		bool @isStatic { get; set; }
  		bool @isFinal { get; set; }
  	}
  
  	public sealed partial class @Variable : GRGEN_LGSP.LGSPNode, GRGEN_MODEL.IVariable
  	{
  		private static int poolLevel = 0;
  		private static GRGEN_MODEL.@Variable[] pool = new GRGEN_MODEL.@Variable[10];
  		
  		// explicit initializations of Variable for target Variable
  		// implicit initializations of Variable for target Variable
  		static @Variable() {
  		}
  		
  		public @Variable() : base(GRGEN_MODEL.NodeType_Variable.typeVar)
  		{
  			// implicit initialization, container creation of Variable
  			// explicit initializations of Variable for target Variable
  		}
  
  		public static GRGEN_MODEL.NodeType_Variable TypeInstance { get { return GRGEN_MODEL.NodeType_Variable.typeVar; } }
  
  		public override GRGEN_LIBGR.INode Clone() { return new GRGEN_MODEL.@Variable(this); }
  
  		private @Variable(GRGEN_MODEL.@Variable oldElem) : base(GRGEN_MODEL.NodeType_Variable.typeVar)
  		{
  			name_M0no_suXx_h4rD = oldElem.name_M0no_suXx_h4rD;
  			visibility_M0no_suXx_h4rD = oldElem.visibility_M0no_suXx_h4rD;
  			isStatic_M0no_suXx_h4rD = oldElem.isStatic_M0no_suXx_h4rD;
  			isFinal_M0no_suXx_h4rD = oldElem.isFinal_M0no_suXx_h4rD;
  		}
  
  		public override bool AreAttributesEqual(GRGEN_LIBGR.IGraphElement that) {
  			if(!(that is @Variable)) return false;
  			@Variable that_ = (@Variable)that;
  			return true
  				&& name_M0no_suXx_h4rD == that_.name_M0no_suXx_h4rD
  				&& visibility_M0no_suXx_h4rD == that_.visibility_M0no_suXx_h4rD
  				&& isStatic_M0no_suXx_h4rD == that_.isStatic_M0no_suXx_h4rD
  				&& isFinal_M0no_suXx_h4rD == that_.isFinal_M0no_suXx_h4rD
  			;
  		}
  
  		public static GRGEN_MODEL.@Variable CreateNode(GRGEN_LGSP.LGSPGraph graph)
  		{
  			GRGEN_MODEL.@Variable node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Variable();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Variable
  				node.@name = null;
  				node.@visibility = null;
  				node.@isStatic = false;
  				node.@isFinal = false;
  				// explicit initializations of Variable for target Variable
  			}
  			graph.AddNode(node);
  			return node;
  		}
  
  		public static GRGEN_MODEL.@Variable CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
  		{
  			GRGEN_MODEL.@Variable node;
  			if(poolLevel == 0)
  				node = new GRGEN_MODEL.@Variable();
  			else
  			{
  				node = pool[--poolLevel];
  				node.lgspInhead = null;
  				node.lgspOuthead = null;
  				node.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
  				// implicit initialization, container creation of Variable
  				node.@name = null;
  				node.@visibility = null;
  				node.@isStatic = false;
  				node.@isFinal = false;
  				// explicit initializations of Variable for target Variable
  			}
  			graph.AddNode(node, nodeName);
  			return node;
  		}
  
  		public override void Recycle()
  		{
  			if(poolLevel < 10)
  				pool[poolLevel++] = this;
  		}
  
  
  		private string name_M0no_suXx_h4rD;
  		public string @name
  		{
  			get { return name_M0no_suXx_h4rD; }
  
gt: 			set { name_M0no_suXx_h4rD = value; }