public static [email protected] CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
		{
			[email protected] node;
			if(poolLevel == 0)
				node = new [email protected]();
			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 static [email protected] CreateEdge(GRGEN_LGSP.LGSPNamedGraph graph, GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target, string edgeName)
		{
			[email protected] edge;
			if(poolLevel == 0)
				edge = new [email protected](source, target);
			else
			{
				edge = pool[--poolLevel];
				edge.lgspFlags &= ~(uint) GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
				edge.lgspSource = source;
				edge.lgspTarget = target;
				// implicit initialization, container creation of UEdge
			}
			graph.AddEdge(edge, edgeName);
			return edge;
		}

        public static bool ApplyXGRS_createEdge(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_LIBGR.INode var_n1, GRGEN_LIBGR.INode var_n2, ref GRGEN_LIBGR.IEdge var_e)
		{
			// it is recommended to create an edge as in the function below, immediately adding it to the graph
			// then you must work with LGSPNodes, casting the INodes you receive as parameters to that concrete type (inheriting from INode)
			var_e = GRGEN_MODEL.E.TypeInstance.CreateEdge(var_n1, var_n2);
			procEnv.graph.AddEdge(var_e); 
			return true;
		}

 public static bool ApplyXGRS_foo(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, int var_v1, double var_v2, GRGEN_MODEL.ENUM_Enu var_v3, string var_v4, bool var_v5, ref int var_r1, ref double var_r2, ref GRGEN_MODEL.ENUM_Enu var_r3, ref string var_r4, ref bool var_r5)
 {
     var_r1 = var_v1;
     var_r2 = var_v2;
     var_r3 = var_v3;
     var_r4 = var_v4;
     var_r5 = var_v5;
     return true;
 }

 public static bool ApplyXGRS_huh(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv)
 {
     object x = procEnv.GetVariableValue("x");
     GRGEN_LGSP.LGSPGraph graph = procEnv.graph;
     GRGEN_LGSP.LGSPActions actions = procEnv.curActions;
     object a = procEnv.GetVariableValue("a");
     GRGEN_MODEL.N node_a = (GRGEN_MODEL.N)a;
     int val_x = (int)x;
     // announce change so that debugger can show new value or transaction manager can record it and roll it back
     graph.ChangingNodeAttribute(node_a, GRGEN_MODEL.NodeType_N.AttributeType_i, GRGEN_LIBGR.AttributeChangeType.Assign, val_x, null);
     node_a.i = val_x;
     // add reflexive edge
     GRGEN_MODEL.E someEdge = GRGEN_MODEL.E.CreateEdge(graph, node_a, node_a);
     // here you could do other nifty things like deleting nodes, retyping graph elements, or calling rules
     return false;
 }

 public static void Filter_filterBass_auto(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_LIBGR.IMatchesExact<Rule_filterBass.IMatch_filterBass> matches)
 {
     if(matches.Count<2)
     	return;
     List<Rule_filterBass.IMatch_filterBass> matchesArray = matches.ToList();
     for(int i = 0; i < matchesArray.Count; ++i)
     {
         if(matchesArray[i] == null)
         	continue;
         for(int j = i + 1; j < matchesArray.Count; ++j)
         {
             if(matchesArray[j] == null)
             	continue;
             if(GRGEN_LIBGR.SymmetryChecker.AreSymmetric(matchesArray[i], matchesArray[j], procEnv.graph))
             	matchesArray[j] = null;
         }
     }
     matches.FromList();
 }

		public @[email protected] CreateEdgewritesTo(GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target, string edgeName)
		{
			return @[email protected](this, source, target, edgeName);
		}

 public static void Filter_f2(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_LIBGR.IMatchesExact<Rule_filterBass.IMatch_filterBass> matches)
 {
     // inspect matches carefully and manipulate as needed
     IEnumerator<Rule_filterBass.IMatch_filterBass> e = matches.GetEnumeratorExact();
     while(e.MoveNext())
     {
         Rule_filterBass.IMatch_filterBass match = e.Current;
         if(match.node_n.i != 42)
             break;
     }
 }

 public static void Filter_f1(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_LIBGR.IMatchesExact<Rule_filterBase.IMatch_filterBase> matches)
 {
     // just let pass
 }

		public @[email protected] CreateEdgemethodBodyContains(GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target, string edgeName)
		{
			return @[email protected](this, source, target, edgeName);
		}

 public static bool ApplyXGRS_bla(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_MODEL.IN var_v1, GRGEN_MODEL.IE var_v2, ref GRGEN_MODEL.IN var_r1, ref GRGEN_MODEL.IE var_r2)
 {
     var_r1 = var_v1;
     var_r2 = var_v2;
     return true;
 }

		public @[email protected] CreateEdgebindsTo(GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target)
		{
			return @[email protected](this, source, target);
		}

 public static bool ApplyXGRS_bar(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, object var_v1, object var_v2, ref object var_r1)
 {
     var_r1 = var_v1 ?? var_v2;
     return true;
 }

		public @UEdge(GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target)
			: base(GRGEN_MODEL.EdgeType_UEdge.typeVar, source, target)
		{
			// implicit initialization, container creation of UEdge
		}

		public @[email protected] CreateEdgeclassContainsClass(GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target, string edgeName)
		{
			return @[email protected](this, source, target, edgeName);
		}

 public static void Filter_f3(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_LIBGR.IMatchesExact<Rule_filterBass.IMatch_filterBass> matches)
 {
     // inspect matches carefully and manipulate as needed, 
     // transforming to a List<IMatch> for easier manipulation and back to an IMatchesExact if needed
     List<Rule_filterBass.IMatch_filterBass> matchesArray = matches.ToList();
     matchesArray.Reverse();
     Rule_filterBass.IMatch_filterBass match = matchesArray[matchesArray.Count-1];
     matchesArray[matchesArray.Count - 1] = null; // setting to null is an efficient way to delete, better than List.RemoveAt
     ++match.node_n.i;
     matchesArray.Add(match);
     matchesArray.Reverse();
     matches.FromList();
 }

		public StdIndexSet(GRGEN_LGSP.LGSPGraph graph)
		{
		}

 public static void Filter_f4(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, GRGEN_LIBGR.IMatchesExact<Rule_filterHass.IMatch_filterHass> matches, System.Int32 i, System.String s)
 {
     // inspect matches carefully and manipulate as needed, depending on input parameters
     // transforming to a List<IMatch> for easier manipulation and back to an IMatchesExact if needed
     List<Rule_filterHass.IMatch_filterHass> matchesArray = matches.ToList();
     for(int j = 0; j < matchesArray.Count; ++j)
     {
         Rule_filterHass.IMatch_filterHass match = matchesArray[j];
         if(match.node_n.i < i)
         {
             matchesArray[j] = null; // setting to null is an efficient way to delete, better than List.RemoveAt
         }
         if(match.node_n.s != s)
         {
             match.node_n.s = s;
         }
     }
     matches.FromList();
 }

		public void FillAsClone(GRGEN_LGSP.LGSPGraph originalGraph, IDictionary<GRGEN_LIBGR.IGraphElement, GRGEN_LIBGR.IGraphElement> oldToNewMap)
		{
		}

 public static bool ApplyXGRS_isnull(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv, object var_v1)
 {
     return var_v1 == null;
 }